diff --git a/claudedocs/_index.md b/claudedocs/_index.md
index eb130a3b..6ea36828 100644
--- a/claudedocs/_index.md
+++ b/claudedocs/_index.md
@@ -1,6 +1,6 @@
 # claudedocs 문서 맵
 
-> 프로젝트 기술 문서 인덱스 (Last Updated: 2025-12-01)
+> 프로젝트 기술 문서 인덱스 (Last Updated: 2025-12-02)
 
 ## 폴더 구조
 
@@ -9,6 +9,7 @@ claudedocs/
 ├── _index.md           # 이 파일 - 문서 맵
 ├── auth/               # 🔐 인증 & 토큰 관리
 ├── item-master/        # 📦 품목기준관리
+├── sales/              # 💰 판매관리 (견적/거래처)
 ├── dashboard/          # 📊 대시보드 & 사이드바
 ├── api/                # 🔌 API 통합
 ├── guides/             # 📚 범용 가이드
@@ -39,8 +40,10 @@ claudedocs/
 
 | 파일 | 설명 |
 |------|------|
-| `[PLAN-2025-12-01] service-layer-refactoring.md` | 📋 **검토 대기** - 서비스 레이어 리팩토링 계획 (도메인 로직 중앙화) |
-| `[PLAN-2025-11-28] dynamic-item-form-implementation.md` | ✅ **Phase 1-6 완료** - 품목관리 동적 렌더링 구현 (타입, 훅, 필드, 렌더러, 메인폼, Feature Flag) |
+| `[PLAN-2025-12-01] service-layer-refactoring.md` | ✅ **완료** - 서비스 레이어 리팩토링 계획 (도메인 로직 중앙화) |
+| `[REF-2025-12-01] state-sync-solutions.md` | 📋 **참조** - 상태 동기화 문제 및 해결 방안 (정규화, React Query 등) |
+| `[PLAN-2025-11-28] dynamic-item-form-implementation.md` | ⚠️ **롤백됨** - 이전 구현 계획 (참조용) |
+| `[IMPL-2025-12-02] dynamic-item-form-rebuild.md` | 🔄 **진행중** - 품목관리 동적 페이지 재구현 (디자인 100% 동일 유지) |
 | `[API-REQUEST-2025-11-28] dynamic-page-rendering-api.md` | ⭐ **v3.1** - 동적 페이지 렌더링 API 요청서 (ID 기반 통일) |
 | `[PLAN-2025-11-27] item-form-component-separation.md` | ✅ **완료** - ItemForm 컴포넌트 분리 (1607→415줄, 74% 감소) |
 | `[IMPL-2025-11-27] realtime-sync-fixes.md` | 실시간 동기화 수정 (BOM, 섹션 복제, 항목 수정, **페이지 삭제 시 섹션 동기화** 2025-11-28) |
@@ -56,6 +59,14 @@ claudedocs/
 
 ---
 
+## 💰 sales/ - 판매관리 (견적/거래처)
+
+| 파일 | 설명 |
+|------|------|
+| `[PLAN-2025-12-02] sales-pages-migration.md` | 📋 **신규** - 견적관리/거래처관리 마이그레이션 계획 |
+
+---
+
 ## 📊 dashboard/ - 대시보드 & 사이드바
 
 | 파일 | 설명 |
diff --git a/claudedocs/item-master/[IMPL-2025-12-02] dynamic-item-form-fixes.md b/claudedocs/item-master/[IMPL-2025-12-02] dynamic-item-form-fixes.md
new file mode 100644
index 00000000..1cd14680
--- /dev/null
+++ b/claudedocs/item-master/[IMPL-2025-12-02] dynamic-item-form-fixes.md	
@@ -0,0 +1,110 @@
+# DynamicItemForm 수정 내역 (2025-12-02)
+
+## 완료된 작업
+
+### 1. 디자인 수정 (2카드 → 1카드)
+- **파일**: `src/components/items/DynamicItemForm/index.tsx`
+- **내용**: 첫 번째 섹션을 "기본 정보" 카드에 통합
+- **결과**: 목업과 동일한 단일 카드 레이아웃
+
+### 2. 필드 순서 정렬
+- **순서**: 품목유형 → 품목명 → 규격(사양) → 품목코드(자동생성) → 단위 → 비고
+- **방법**: `item_name`, `specification` 필드 우선 렌더링 후 품목코드, 나머지 필드 순서
+
+### 3. 단위 드롭다운 field_key 매칭 개선
+- **파일**: `src/components/items/DynamicItemForm/fields/DropdownField.tsx`
+- **수정**: 한글 '단위' 포함 매칭 추가
+```typescript
+const isUnitField =
+  fieldKey.toLowerCase().includes('unit') ||
+  fieldKey.includes('단위') ||
+  field.field_name.includes('단위') ||
+  field.field_name.toLowerCase().includes('unit');
+```
+
+### 4. aria-hidden 충돌 해결
+- **파일**: `src/components/ui/sheet.tsx`, `src/components/ui/select.tsx`
+- **수정**: `modal={false}` 추가
+- **이유**: Sheet(사이드바)와 Select 드롭다운 간 aria-hidden 충돌 방지
+
+### 5. 필드명 매핑 (프론트 → 백엔드)
+- **파일**: `src/components/items/DynamicItemForm/index.tsx`
+- **매핑 테이블**:
+```typescript
+const fieldKeyToBackendKey: Record<string, string> = {
+  'item_name': 'name',
+  'specification': 'spec',
+  'unit': 'unit',
+  'note': 'note',
+  'description': 'description',
+};
+```
+- **추가 매핑**:
+  - `item_type` → `product_type`
+  - `item_code` → `code`
+
+---
+
+## 발견된 백엔드 이슈 (미해결)
+
+### 1. unitOptions 빈 배열
+- **현상**: init API 응답에 `unitOptions: []` 빈 배열
+- **영향**: 단위 드롭다운에 옵션이 없음
+- **해결 필요**:
+  - 품목기준관리 속성 탭의 단위 데이터를 DB에 저장
+  - init API에서 `item_unit_options` 테이블 조회 후 반환
+
+### 2. category_id 필수 필드
+- **현상**: `Field 'category_id' doesn't have a default value` 에러
+- **해결 필요**:
+  - `products` 테이블의 `category_id` nullable 또는 기본값 설정
+  - 또는 API에서 기본 category_id 처리
+
+### 3. GET /items API 품목 조회 안됨
+- **현상**: 품목 저장 후 목록에서 안 보임
+- **응답**: `"data": [], "total": 0`
+- **확인 필요**:
+  - POST `/items` → `products` 테이블 저장
+  - GET `/items` → 어떤 테이블 조회하는지?
+  - tenant_id 조건 확인
+
+---
+
+## 수정된 파일 목록
+
+```
+src/components/items/DynamicItemForm/index.tsx
+src/components/items/DynamicItemForm/fields/DropdownField.tsx
+src/components/items/DynamicItemForm/hooks/useFormStructure.ts
+src/components/ui/sheet.tsx
+src/components/ui/select.tsx
+```
+
+---
+
+## 다음 세션에서 할 일
+
+1. [ ] 백엔드 이슈 해결 확인 (unitOptions, category_id, GET /items)
+2. [ ] 단위 드롭다운 정상 동작 테스트
+3. [ ] 품목 저장 후 목록에서 조회 테스트
+4. [ ] 다른 품목 유형(FG, PT, SM, RM) 테스트
+5. [ ] 디버그 console.log 제거
+
+---
+
+## 백엔드 요청 사항 정리
+
+```markdown
+### 1. unitOptions 반환
+📍 API: GET /api/v1/item-master/init
+📍 요청: unitOptions에 item_unit_options 테이블 데이터 포함
+
+### 2. category_id 기본값
+📍 테이블: products
+📍 요청: category_id NULL 허용 또는 기본값 설정
+
+### 3. GET /items 품목 조회
+📍 API: GET /api/v1/items
+📍 문제: 저장한 품목이 조회되지 않음
+📍 확인: products 테이블 조회하는지, tenant_id 조건 확인
+```
\ No newline at end of file
diff --git a/claudedocs/item-master/[IMPL-2025-12-02] dynamic-item-form-rebuild.md b/claudedocs/item-master/[IMPL-2025-12-02] dynamic-item-form-rebuild.md
new file mode 100644
index 00000000..585975ba
--- /dev/null
+++ b/claudedocs/item-master/[IMPL-2025-12-02] dynamic-item-form-rebuild.md	
@@ -0,0 +1,223 @@
+# 품목 등록 동적 페이지 재구현
+
+## 작업 일자: 2025-12-02
+
+## 문서 버전
+| 버전 | 날짜 | 작성자 | 내용 |
+|------|------|--------|------|
+| 1.0 | 2025-12-02 | Claude | 롤백 후 재구현 시작 |
+| 1.1 | 2025-12-02 | Claude | Phase 1-8 완료 |
+
+---
+
+## 배경
+
+- 이전 작업에서 DynamicItemForm 구현이 디자인 누락으로 롤백됨
+- 기존 ItemForm (목업 데이터 기반)의 디자인을 100% 유지하면서 동적 렌더링 구현 필요
+
+---
+
+## 핵심 원칙
+
+1. **디자인 100% 동일**: 기존 ItemForm과 완벽히 동일한 UI/UX
+2. **밸리데이션 동일**: 에러 메시지 위치, 스타일 동일
+3. **버튼/아이콘 동일**: 모든 버튼, 아이콘 위치 및 스타일 동일
+4. **화면 등장 순서 동일**: 섹션 표시 순서, 조건부 렌더링 동일
+5. **동적 구성**: 품목기준관리 API 기반으로 필드/섹션 동적 생성
+
+---
+
+## 체크리스트
+
+### Phase 1: 현재 상태 분석
+- [x] 기존 ItemForm 디자인 완전 분석
+  - [x] 품목 유형 선택 UI
+  - [x] 기본 정보 섹션 레이아웃
+  - [x] BOM 섹션 레이아웃
+  - [x] 전개도 섹션 레이아웃
+  - [x] 버튼 위치 및 스타일
+  - [x] 밸리데이션 에러 표시 방식
+- [x] 품목관리 API 응답 구조 확인 (init, pages.getStructure)
+
+### Phase 2: DynamicItemForm 폴더 생성
+- [x] 기본 폴더 구조 생성
+  ```
+  src/components/items/DynamicItemForm/
+  ├── index.tsx
+  ├── types.ts
+  ├── hooks/
+  │   ├── index.ts
+  │   ├── useFormStructure.ts
+  │   └── useDynamicFormState.ts
+  └── fields/
+      ├── index.ts
+      ├── TextField.tsx
+      ├── DropdownField.tsx
+      ├── NumberField.tsx
+      ├── DateField.tsx
+      ├── TextareaField.tsx
+      ├── CheckboxField.tsx
+      └── DynamicFieldRenderer.tsx
+  ```
+
+### Phase 3: 타입 정의
+- [x] `types.ts` - 동적 폼 관련 타입 정의
+- [x] API 응답 타입과 프론트엔드 타입 매핑
+- [x] SimpleUnitOption 타입 추가
+
+### Phase 4: 훅 구현
+- [x] `useFormStructure.ts` - API에서 폼 구조 로드
+- [x] `useDynamicFormState.ts` - 동적 상태 관리
+
+### Phase 5: 필드 컴포넌트 구현 (디자인 100% 동일)
+- [x] `TextField.tsx` - 기존 Input 스타일 동일
+- [x] `DropdownField.tsx` - 기존 Select 스타일 동일
+- [x] `NumberField.tsx` - 기존 숫자 입력 스타일 동일
+- [x] `DateField.tsx` - 기존 날짜 선택 스타일 동일
+- [x] `TextareaField.tsx` - 기존 텍스트영역 스타일 동일
+- [x] `CheckboxField.tsx` - 기존 체크박스 스타일 동일
+- [x] `DynamicFieldRenderer.tsx` - 필드 타입별 렌더러
+
+### Phase 6: 메인 폼 컴포넌트
+- [x] `index.tsx` - 메인 동적 폼 컴포넌트
+  - [x] 기존 ItemForm과 동일한 레이아웃
+  - [x] 동일한 헤더 스타일 (FormHeader 인라인)
+  - [x] 동일한 ValidationAlert 스타일
+  - [x] 동일한 섹션 Card 스타일
+  - [x] 동일한 버튼 배치
+
+### Phase 7: 기존 ItemForm 주석처리 및 전환
+- [x] `/items/create/page.tsx` - DynamicItemForm으로 전환
+- [x] 기존 ItemForm import 주석처리
+- [x] 전환 테스트 준비
+
+### Phase 8: API 연동
+- [x] POST /api/proxy/items 연동 구현
+- [x] 품목 등록 후 목록 페이지 이동
+- [x] 에러 처리
+
+### Phase 9: 테스트
+- [x] TypeScript 빌드 검증 완료 (DynamicItemForm 에러 없음)
+- [ ] 품목 유형별 등록 테스트 (FG, PT, RM, SM, CS)
+- [ ] 밸리데이션 테스트
+- [ ] API 연동 테스트
+- [ ] 품목 목록에 등록된 데이터 표시 확인
+
+---
+
+## 테스트 가이드
+
+### 사전 조건
+1. 백엔드 서버 실행 (sam-api)
+2. 프론트엔드 개발 서버 실행 (`npm run dev`)
+3. 품목기준관리에서 페이지/섹션/필드 설정 완료
+
+### 테스트 항목
+
+#### 1. 품목 등록 페이지 접근
+```
+URL: http://localhost:3000/items/create
+```
+- [ ] 페이지 로딩 시 "폼 구조를 불러오는 중..." 표시
+- [ ] 품목 유형 선택 전 안내 메시지 표시
+
+#### 2. 품목 유형 선택
+- [ ] FG (완제품) 선택 시 해당 폼 구조 로드
+- [ ] PT (부품) 선택 시 해당 폼 구조 로드
+- [ ] RM (원자재) 선택 시 해당 폼 구조 로드
+- [ ] SM (부자재) 선택 시 해당 폼 구조 로드
+- [ ] CS (소모품) 선택 시 해당 폼 구조 로드
+
+#### 3. 필드 렌더링
+- [ ] 텍스트 필드 정상 렌더링
+- [ ] 숫자 필드 정상 렌더링
+- [ ] 드롭다운 필드 정상 렌더링 (단위 옵션 포함)
+- [ ] 체크박스 필드 정상 렌더링
+- [ ] 날짜 필드 정상 렌더링
+- [ ] 텍스트영역 필드 정상 렌더링
+
+#### 4. 밸리데이션
+- [ ] 필수 필드 빈값 시 에러 메시지 표시
+- [ ] ValidationAlert에 에러 목록 표시
+- [ ] 에러 필드에 빨간 테두리 표시
+
+#### 5. API 연동
+- [ ] 저장 버튼 클릭 시 POST /api/proxy/items 호출
+- [ ] 저장 성공 시 /items 페이지로 이동
+- [ ] 저장 실패 시 에러 메시지 표시
+
+#### 6. 디자인 검증
+- [ ] 기존 ItemForm과 레이아웃 동일
+- [ ] 헤더 스타일 동일 (아이콘, 버튼 위치)
+- [ ] 섹션 Card 스타일 동일
+- [ ] 필드 라벨/에러 스타일 동일
+
+---
+
+## 생성된 파일
+
+### DynamicItemForm 컴포넌트
+- `src/components/items/DynamicItemForm/index.tsx` - 메인 폼 (388줄)
+- `src/components/items/DynamicItemForm/types.ts` - 타입 정의
+- `src/components/items/DynamicItemForm/hooks/index.ts` - 훅 export
+- `src/components/items/DynamicItemForm/hooks/useFormStructure.ts` - 폼 구조 로드
+- `src/components/items/DynamicItemForm/hooks/useDynamicFormState.ts` - 상태 관리
+- `src/components/items/DynamicItemForm/fields/index.ts` - 필드 export
+- `src/components/items/DynamicItemForm/fields/TextField.tsx`
+- `src/components/items/DynamicItemForm/fields/NumberField.tsx`
+- `src/components/items/DynamicItemForm/fields/DropdownField.tsx`
+- `src/components/items/DynamicItemForm/fields/CheckboxField.tsx`
+- `src/components/items/DynamicItemForm/fields/DateField.tsx`
+- `src/components/items/DynamicItemForm/fields/TextareaField.tsx`
+- `src/components/items/DynamicItemForm/fields/DynamicFieldRenderer.tsx`
+
+### 수정된 파일
+- `src/app/[locale]/(protected)/items/create/page.tsx` - DynamicItemForm 사용으로 변경
+
+---
+
+## API 흐름
+
+```
+1. useFormStructure(itemType)
+   └─> itemMasterApi.init()
+       └─> /api/proxy/item-master/init
+           └─> pages, sections, fields, unitOptions 반환
+
+2. itemMasterApi.pages.getStructure(pageId)
+   └─> /api/proxy/item-master/pages/{id}/structure
+       └─> page, sections, directFields 반환
+
+3. 품목 등록
+   └─> POST /api/proxy/items
+       └─> body: DynamicFormData
+```
+
+---
+
+## 디자인 매칭 요소
+
+### 레이아웃
+- `form` > `space-y-6`
+- `Card` > `CardHeader` > `CardTitle` > `CardContent`
+- `grid grid-cols-1 md:grid-cols-2 gap-4`
+
+### 필드 스타일
+- Label with required marker: `<span className="text-red-500"> *</span>`
+- Error state: `className={error ? 'border-red-500' : ''}`
+- Error message: `<p className="text-xs text-red-500 mt-1">{error}</p>`
+- Helper text: `<p className="text-xs text-muted-foreground mt-1">* ...</p>`
+
+### 버튼 스타일
+- Cancel: `variant="outline" size="sm"`
+- Submit: `size="sm" disabled={!selectedItemType || isSubmitting}`
+- Icons: `X`, `Save` from lucide-react
+
+---
+
+## 변경 이력
+
+| 날짜 | 작업 내용 |
+|------|----------|
+| 2025-12-02 | 문서 생성, Phase 1 시작 |
+| 2025-12-02 | Phase 1-8 완료: DynamicItemForm 전체 구현 |
\ No newline at end of file
diff --git a/claudedocs/item-master/[IMPL-2025-12-02] item-code-auto-generation.md b/claudedocs/item-master/[IMPL-2025-12-02] item-code-auto-generation.md
new file mode 100644
index 00000000..60660915
--- /dev/null
+++ b/claudedocs/item-master/[IMPL-2025-12-02] item-code-auto-generation.md	
@@ -0,0 +1,81 @@
+# 품목코드 자동생성 로직
+
+## 개요
+
+품목코드는 품목기준관리에서 별도 필드로 등록하지 않고, **프론트엔드(DynamicItemForm)에서 자동 생성**한다.
+
+## 배경
+
+- 품목기준관리 API에 "자동생성 필드" 설정 기능이 아직 없음 (TODO 상태)
+- 당장 테스트를 위해 프론트에서 처리하기로 결정 (2025-12-02)
+
+## 자동생성 규칙 (2025-12-03 업데이트)
+
+### PT (부품) - 영문약어-순번 형식
+```
+품목명 선택 → 영문약어 매핑 조회 → 기존 품목코드에서 순번 계산 → 코드 생성
+
+예시:
+- 가이드레일 → GR → GR-001, GR-002, ...
+- 모터 → MOTOR → MOTOR-001, MOTOR-002, ...
+- 제어기 → CTL → CTL-001, CTL-002, ...
+```
+
+### 기타 품목 (FG, SM, RM, CS) - 품목명-규격 형식
+```
+IF 해당 페이지에 item_name 필드 존재
+AND specification 필드 존재
+THEN
+  → "품목코드 (자동생성)" 읽기전용 필드 자동 표시
+  → 값: {품목명}-{규격}
+  → 저장 시 품목관리 API의 code로 전달
+```
+
+## 영향 범위
+
+### 품목기준관리에 등록할 필드 (CS 소모품 예시)
+
+| 필드명 | field_key | field_type | 비고 |
+|--------|-----------|------------|------|
+| 품목명 | `item_name` | textbox | 필수 |
+| 규격(사양) | `specification` | textbox | 필수 |
+| 단위 | `unit` | dropdown | 필수 |
+| 비고 | `note` | textarea | 선택 |
+
+### 품목기준관리에 등록하지 않는 필드
+
+| 필드명 | 이유 |
+|--------|------|
+| 품목코드 | 프론트에서 자동생성 |
+
+## 구현 위치
+
+- **파일**: `src/components/items/DynamicItemForm/index.tsx`
+- **로직**:
+  1. `structure`에서 `item_name`, `specification` 필드 존재 여부 체크
+  2. 둘 다 있으면 품목코드 읽기전용 필드 렌더링
+  3. 값은 `formData.item_name` + `-` + `formData.specification`
+  4. 저장 시 `submitData.item_code`에 포함
+
+## 향후 계획
+
+- 품목기준관리 API에 `properties.autoGenerate` 설정 기능 추가 시 마이그레이션
+- 예시 설정:
+```json
+{
+  "field_name": "품목코드",
+  "field_type": "textbox",
+  "properties": {
+    "autoGenerate": {
+      "formula": "{item_name}-{specification}",
+      "readonly": true
+    }
+  }
+}
+```
+
+## 관련 문서
+
+- `[PLAN-2025-11-28] dynamic-item-form-implementation.md`
+- `[IMPL-2025-12-02] dynamic-item-form-rebuild.md`
+- `[REF] item-code-hardcoding.md` - PT 품목코드 하드코딩 내역 상세
\ No newline at end of file
diff --git a/claudedocs/item-master/[PLAN-2025-11-28] dynamic-item-form-implementation.md b/claudedocs/item-master/[PLAN-2025-11-28] dynamic-item-form-implementation.md
index eadfcc7a..429f3283 100644
--- a/claudedocs/item-master/[PLAN-2025-11-28] dynamic-item-form-implementation.md	
+++ b/claudedocs/item-master/[PLAN-2025-11-28] dynamic-item-form-implementation.md	
@@ -195,9 +195,9 @@ src/components/items/
   - [x] DrawingCanvasSimple (파일 업로드 기반)
   - [x] BOMTable (품목 구성 관리)
   - [x] BendingDetailTable (전개도 상세 입력 + 자동 계산)
-- [ ] 페이지 라우트 업데이트 (API 구현 후 진행)
-  - [ ] `/items/create/page.tsx`
-  - [ ] `/items/[id]/edit/page.tsx`
+- [x] 페이지 라우트 업데이트 ✅ 완료 (2025-12-01)
+  - [x] `/items/create/page.tsx` → DynamicItemForm 연동
+  - [x] `/items/[id]/edit/page.tsx` → DynamicItemForm + 실제 API 연동
 
 ### Phase 7: 테스트 및 검증
 - [ ] 품목 유형별 테스트
@@ -347,4 +347,5 @@ src/components/items/
 
 | 날짜 | 버전 | 변경 내용 |
 |------|------|----------|
-| 2025-11-28 | 1.0 | 초안 작성 |
\ No newline at end of file
+| 2025-11-28 | 1.0 | 초안 작성 |
+| 2025-12-01 | 1.1 | Phase 6 페이지 라우트 업데이트 완료 (API 연동) |
\ No newline at end of file
diff --git a/claudedocs/item-master/[REF-2025-12-01] state-sync-solutions.md b/claudedocs/item-master/[REF-2025-12-01] state-sync-solutions.md
new file mode 100644
index 00000000..d400a6bb
--- /dev/null
+++ b/claudedocs/item-master/[REF-2025-12-01] state-sync-solutions.md	
@@ -0,0 +1,225 @@
+# 품목기준관리 상태 동기화 문제 및 해결 방안
+
+**작성일**: 2025-12-01
+**상태**: 참조 문서
+**관련**: 서비스 레이어 리팩토링 후 발생한 동기화 버그 분석
+
+---
+
+## 1. 오늘 발생한 버그 분석
+
+### 1.1 실시간 동기화 문제 (sectionsAsTemplates 순서)
+
+```
+문제: 섹션탭에서 항목 추가 → 계층구조만 업데이트, 항목탭/속성탭은 안됨
+원인: Map 중복 제거 시 unlinkedSections가 linkedSections를 덮어씀
+해결: [...unlinkedSections, ...linkedSections] 순서로 변경
+```
+
+**리팩토링으로 해결 가능?** ❌ 아니다. **데이터 소스 우선순위** 문제.
+
+### 1.2 422 Validation Error
+
+```
+문제: 섹션탭에서 일반 섹션 항목 추가 시 422 에러
+원인: 섹션탭은 POST /fields, 계층구조탭은 POST /sections/{id}/fields 사용
+해결: 섹션탭도 addFieldToSection() 사용하도록 통일
+```
+
+**리팩토링으로 해결 가능?** ⚠️ 부분적. 서비스 레이어에서 API 선택을 중앙화할 수 있었지만, 두 탭이 **다른 API를 호출하는 것 자체**가 문제.
+
+### 1.3 페이지 삭제 시 필드 소실
+
+```
+문제: 페이지 삭제 → 섹션의 필드까지 사라짐
+원인: refreshIndependentSections()가 필드 없이 섹션만 반환
+해결: 페이지의 섹션들을 직접 independentSections에 추가
+```
+
+**리팩토링으로 해결 가능?** ❌ 아니다. **백엔드 API 응답 불완전성** + **상태 동기화 전략** 문제.
+
+---
+
+## 2. 근본 원인: 동기화가 애매한 구조
+
+### 2.1 현재 아키텍처의 문제점
+
+```
+┌─────────────────────────────────────────────────┐
+│ 같은 "섹션" 데이터가 2곳에서 관리됨              │
+├─────────────────────────────────────────────────┤
+│ 1. itemPages[].sections[] ← 페이지에 연결된 섹션 │
+│ 2. independentSections[]  ← 독립 섹션            │
+├─────────────────────────────────────────────────┤
+│ 문제: 두 소스가 동기화되지 않으면 불일치 발생!   │
+└─────────────────────────────────────────────────┘
+```
+
+### 2.2 서비스 레이어 리팩토링의 한계
+
+| 해결 가능 | 해결 불가 |
+|-----------|-----------|
+| ✅ validation/파싱 로직 중복 제거 | ❌ 상태 동기화 문제 |
+| ✅ 코드 유지보수성 향상 | ❌ 데이터 소스 불일치 |
+| ✅ 도메인 로직 중앙화 | ❌ API 응답 불완전성 |
+
+---
+
+## 3. 해결 방안
+
+### 방법 1: 정규화된 상태 (Normalized State) ⭐ 권장
+
+```typescript
+// 현재 구조 (중첩, 중복 가능)
+{
+  itemPages: [
+    { id: 1, sections: [{ id: 10, fields: [...] }] }
+  ],
+  independentSections: [
+    { id: 10, fields: [...] }  // 같은 섹션이 다른 데이터로 존재!
+  ]
+}
+
+// 정규화된 구조 (Single Source of Truth)
+{
+  entities: {
+    pages: { 1: { id: 1, sectionIds: [10] } },
+    sections: { 10: { id: 10, fieldIds: [100, 101] } },
+    fields: { 100: {...}, 101: {...} }
+  },
+  // 관계는 ID로만 참조
+  ui: {
+    selectedPageId: 1,
+    independentSectionIds: [20, 30]  // ID만 저장
+  }
+}
+```
+
+**장점:**
+- 데이터 중복 없음 → 불일치 원천 차단
+- 한 곳만 수정하면 모든 곳에 반영
+- 메모리 효율적
+
+**구현 도구:** Zustand + immer 또는 Redux Toolkit
+
+---
+
+### 방법 2: Derived State 패턴
+
+```typescript
+// Context에서 원본 데이터는 하나만 유지
+const [allSections, setAllSections] = useState<Section[]>([]);
+const [pageRelations, setPageRelations] = useState<{pageId: number, sectionId: number}[]>([]);
+
+// 필요한 데이터는 계산으로 도출 (useMemo)
+const sectionsForPage = useMemo(() =>
+  allSections.filter(s =>
+    pageRelations.some(r => r.pageId === selectedPageId && r.sectionId === s.id)
+  ), [allSections, pageRelations, selectedPageId]
+);
+
+const independentSections = useMemo(() =>
+  allSections.filter(s =>
+    !pageRelations.some(r => r.sectionId === s.id)
+  ), [allSections, pageRelations]
+);
+```
+
+**장점:**
+- 기존 Context 구조 유지 가능
+- 점진적 마이그레이션 가능
+
+---
+
+### 방법 3: React Query / TanStack Query
+
+```typescript
+// 서버 상태를 캐시로 관리
+const { data: sections } = useQuery({
+  queryKey: ['sections'],
+  queryFn: () => api.getSections({ includeFields: true })
+});
+
+// 뮤테이션 후 자동 갱신
+const deletePage = useMutation({
+  mutationFn: api.deletePage,
+  onSuccess: () => {
+    // 관련 쿼리 자동 갱신
+    queryClient.invalidateQueries(['sections']);
+    queryClient.invalidateQueries(['pages']);
+  }
+});
+```
+
+**장점:**
+- 서버-클라이언트 동기화 자동화
+- 캐싱, 재시도, 낙관적 업데이트 내장
+- 수동 상태 관리 대폭 감소
+
+---
+
+### 방법 4: 백엔드 API 개선
+
+```
+현재: GET /sections → 섹션만 반환 (필드 없음)
+개선: GET /sections?include=fields → 섹션 + 필드 반환
+```
+
+**또는 GraphQL:**
+```graphql
+query {
+  sections {
+    id
+    title
+    fields {  # 필요한 관계 데이터 명시적 요청
+      id
+      field_name
+    }
+  }
+}
+```
+
+---
+
+## 4. 현실적인 적용 순서
+
+| 단계 | 방법 | 난이도 | 효과 | 설명 |
+|------|------|--------|------|------|
+| 1단계 | Derived State 패턴 | 🟢 낮음 | 즉시 적용 가능 | 기존 구조 유지하며 파생 데이터 정리 |
+| 2단계 | 백엔드 API 개선 요청 | 🟡 중간 | 근본 해결 | `include=fields` 파라미터 추가 |
+| 3단계 | React Query 도입 | 🟡 중간 | 동기화 자동화 | 서버 상태 관리 단순화 |
+| 4단계 | 정규화된 상태 | 🔴 높음 | 완전한 해결 | 대규모 리팩토링 필요 |
+
+---
+
+## 5. 프로젝트 추천 방향
+
+### 단기 (즉시 적용 가능)
+- Derived State 패턴으로 `sectionsAsTemplates` 같은 파생 데이터 정리
+- 중복 데이터 소스 최소화
+
+### 중기 (백엔드 협업 필요)
+- 백엔드에 `GET /sections?include=fields` API 추가 요청
+- 관계 데이터 포함 응답으로 프론트엔드 동기화 부담 감소
+
+### 장기 (대규모 개선)
+- React Query 도입으로 서버 상태 관리 단순화
+- 또는 정규화된 상태 구조로 전환
+
+---
+
+## 6. 결론
+
+| 구분 | 내용 |
+|------|------|
+| **서비스 레이어** | 도메인 로직 중복 해결 ✅ |
+| **상태 동기화** | 아키텍처 레벨 개선 필요 ⚠️ |
+| **근본 원인** | 같은 데이터가 여러 곳에서 관리됨 |
+| **해결 방향** | Single Source of Truth 패턴 적용 |
+
+---
+
+## 7. 관련 문서
+
+- `[PLAN-2025-12-01] service-layer-refactoring.md` - 서비스 레이어 리팩토링 계획
+- `[REF-2025-11-26] item-master-hooks-refactoring.md` - 훅 분리 작업 기록
\ No newline at end of file
diff --git a/claudedocs/item-master/[REF] item-code-hardcoding.md b/claudedocs/item-master/[REF] item-code-hardcoding.md
new file mode 100644
index 00000000..310a0ff4
--- /dev/null
+++ b/claudedocs/item-master/[REF] item-code-hardcoding.md	
@@ -0,0 +1,241 @@
+# 품목코드/품목명 자동생성 하드코딩 내역
+
+> MVP용 프론트엔드 구현 - 추후 백엔드 API 또는 품목기준관리 설정으로 이관 필요
+
+## 개요
+
+PT(부품) 품목 등록 시 품목코드와 품목명을 자동 생성하는 로직이 프론트엔드에 하드코딩되어 있습니다.
+이 문서는 해당 하드코딩 내역을 정리하여 추후 백엔드 이관 시 참고할 수 있도록 합니다.
+
+## 품목코드/품목명 생성 규칙
+
+### 적용 범위
+
+| 품목유형 | 품목코드 형식 | 품목명 형식 | 예시 |
+|---------|-------------|------------|------|
+| **PT (부품)** | `영문약어-순번` | 한글 조합 | `GR-001` / `가이드레일 130×80` |
+| FG (제품) | `품목명-규격` | 직접 입력 | `스크린-2400` |
+| SM (부자재) | `품목명-규격` | 직접 입력 | `볼트-M8` |
+| RM (원자재) | `품목명-규격` | 직접 입력 | `알루미늄-T1.5` |
+| CS (소모품) | `품목명-규격` | 직접 입력 | `테이프-50mm` |
+
+---
+
+## 하드코딩 항목 1: 영문약어 매핑 테이블
+
+### 파일 위치
+`src/components/items/DynamicItemForm/utils/itemCodeGenerator.ts`
+
+### 상수명
+`ITEM_CODE_PREFIX_MAP`
+
+### 내용
+```typescript
+export const ITEM_CODE_PREFIX_MAP: Record<string, string> = {
+  // 부품 - 조립품
+  '가이드레일': 'GR',
+  '케이스': 'CASE',
+  '브라켓': 'BRK',
+
+  // 부품 - 구매품
+  '모터': 'MOTOR',
+  '제어기': 'CTL',
+  '전동개폐기': 'OPENER',
+  '스위치': 'SW',
+  '센서': 'SENSOR',
+  '리모컨': 'REMOTE',
+
+  // 부품 - 절곡품
+  '레일': 'RAIL',
+  '커버': 'COVER',
+  '플레이트': 'PLATE',
+
+  // 제품
+  '스크린': 'SCREEN',
+  '셔터': 'SHUTTER',
+  '방화스크린': 'FIRE-SCR',
+  '롤스크린': 'ROLL-SCR',
+
+  // 원자재
+  '알루미늄': 'ALU',
+  '스틸': 'STEEL',
+  '철판': 'STEEL',
+
+  // 부자재/소모품
+  '볼트': 'BOLT',
+  '너트': 'NUT',
+  '와셔': 'WASHER',
+  '나사': 'SCREW',
+};
+```
+
+### 마이그레이션 방안
+- 품목기준관리 API에 `영문약어 설정` 기능 추가
+- 또는 별도 `item_code_prefix` 테이블 생성
+
+---
+
+## 하드코딩 항목 2: 절곡품 코드 체계
+
+### 파일 위치
+`src/components/items/DynamicItemForm/utils/itemCodeGenerator.ts`
+
+### 상수명
+`BENDING_CODE_SYSTEM`
+
+### 내용
+```typescript
+export const BENDING_CODE_SYSTEM = {
+  // 품목명코드 (category2)
+  품목명코드: {
+    'R': '가이드레일',
+    'S': '스크린',
+    'C': '케이스',
+    'B': '박스',
+    'T': '트림',
+    'L': '라스틱',
+    'G': '기타',
+  },
+
+  // 종류코드 (category3)
+  종류코드: {
+    'M': '마감',
+    'T': '티',
+    'C': '채널',
+    'D': '단면',
+    'S': '상부',
+    'U': '하부',
+    'F': '플랫',
+    'P': '피스',
+    'L': '리드',
+    'B': '브라켓',
+    'E': '엔드',
+    'I': '이음',
+    'A': '각재',
+  },
+
+  // 길이코드 매핑 (mm → 코드)
+  길이코드: {
+    1219: '12',
+    2438: '24',
+    3000: '30',
+    3500: '35',
+    4000: '40',
+    4150: '41',
+    4200: '42',
+    4300: '43',
+  },
+};
+```
+
+### 사용 예시
+- 품목명코드 `R` + 종류코드 `C` + 길이코드 `24` = `RC24`
+- 가이드레일 채널 2438mm
+
+### 마이그레이션 방안
+- 품목기준관리 API에 `코드 체계 설정` 기능 추가
+- 또는 별도 `bending_code_system` 테이블 생성
+
+---
+
+## 하드코딩 항목 3: 조립품 설치유형 매핑
+
+### 파일 위치
+`src/components/items/DynamicItemForm/utils/itemCodeGenerator.ts`
+
+### 상수명
+`INSTALLATION_TYPE_MAP`
+
+### 내용
+```typescript
+export const INSTALLATION_TYPE_MAP: Record<string, string> = {
+  'standard': '표준형',
+  'top': '상부형',
+  'bottom': '하부형',
+  'side': '측면형',
+  'custom': '맞춤형',
+};
+```
+
+### 사용 예시
+- 품목명 `가이드레일` + 설치유형 `standard` → `가이드레일표준형`
+
+### 마이그레이션 방안
+- 품목기준관리 필드 옵션으로 설정 가능하도록 변경
+
+---
+
+## 자동생성 함수 목록
+
+### 1. generateItemCode (품목코드 생성)
+```typescript
+// 용도: PT(부품) 품목코드 자동생성
+// 형식: 영문약어-순번 (예: GR-001, MOTOR-002)
+generateItemCode(itemName: string, existingCodes: string[]): string
+```
+
+### 2. generateBendingItemCode (절곡품 품목코드)
+```typescript
+// 용도: 절곡품 전용 품목코드
+// 형식: 품목명코드 + 종류코드 + 길이코드 (예: RC24)
+generateBendingItemCode(category2: string, category3: string, lengthMm: number): string
+```
+
+### 3. generateAssemblyItemName (조립품 품목명)
+```typescript
+// 용도: 조립품 품목명 자동생성
+// 형식: 품목명 + 설치유형 + 측면규격*길이코드 (예: 가이드레일표준형50*60*24)
+generateAssemblyItemName(itemName, installationType, sideSpecWidth, sideSpecHeight, lengthMm): string
+```
+
+### 4. generateBendingItemName (절곡품 품목명)
+```typescript
+// 용도: 절곡품 품목명 자동생성
+// 형식: 품목명 + 종류 + 규격 (예: 가이드레일 채널 50×30)
+generateBendingItemName(category2Label, category3Label, specification): string
+```
+
+### 5. generatePurchasedItemName (구매품 품목명)
+```typescript
+// 용도: 구매품 품목명 자동생성
+// 형식: 품목명 + 규격 (예: 모터 0.4KW)
+generatePurchasedItemName(itemName, specification): string
+```
+
+---
+
+## 추후 개발 계획
+
+### Phase 1: 품목기준관리 설정 확장
+1. `영문약어` 필드 추가 (품목명 필드 옵션에 매핑)
+2. `코드생성규칙` 설정 UI 추가
+3. API에서 코드 생성 규칙 반환
+
+### Phase 2: 백엔드 이관
+1. 품목 저장 시 백엔드에서 코드 자동 생성
+2. 순번 관리를 DB 시퀀스로 변경 (동시성 처리)
+3. 프론트엔드 하드코딩 제거
+
+### Phase 3: 고급 기능
+1. 품목별 코드 생성 규칙 커스터마이징
+2. 코드 중복 검사 강화
+3. 코드 변경 이력 관리
+
+---
+
+## 관련 파일
+
+| 파일 | 설명 |
+|-----|------|
+| `src/components/items/DynamicItemForm/utils/itemCodeGenerator.ts` | 하드코딩된 매핑 및 생성 함수 |
+| `src/components/items/DynamicItemForm/index.tsx` | 품목코드 자동생성 로직 호출 |
+| `claudedocs/item-master/[IMPL-2025-12-02] item-code-auto-generation.md` | 기존 품목코드 자동생성 문서 |
+
+---
+
+## 변경 이력
+
+| 날짜 | 내용 |
+|-----|------|
+| 2025-12-03 | PT 품목코드 `영문약어-순번` 형식 구현 |
+| 2025-12-03 | 하드코딩 내역 문서화 |
\ No newline at end of file
diff --git a/claudedocs/sales/[PLAN-2025-12-02] sales-pages-migration.md b/claudedocs/sales/[PLAN-2025-12-02] sales-pages-migration.md
new file mode 100644
index 00000000..d912ccf5
--- /dev/null
+++ b/claudedocs/sales/[PLAN-2025-12-02] sales-pages-migration.md	
@@ -0,0 +1,455 @@
+# 판매관리 페이지 마이그레이션 계획
+
+> **작성일**: 2025-12-02
+> **소스**: `sam-design/sam-design`
+> **타겟**: `sam-react-prod` (Next.js)
+> **예상 소요 시간**: 4~6시간
+
+---
+
+## 0. 예상 작업 시간
+
+| Phase | 작업 내용 | 예상 시간 |
+|-------|----------|----------|
+| Phase 1 | 공통 UI 컴포넌트 (~1,400줄) | 1~2시간 |
+| Phase 2 | 거래처관리 (~500줄) | 30분~1시간 |
+| Phase 3 | 견적관리 + 하위 컴포넌트 (~1,500줄+) | 2~3시간 |
+| **총합** | **~3,400줄+** | **4~6시간** |
+
+> **참고**: 테스트/디버깅 시간 포함, 예상치 못한 이슈 발생 시 추가 소요 가능
+
+---
+
+## 1. 마이그레이션 대상 요약
+
+| 페이지 | 파일 | 크기 | 분할 필요 | 템플릿 |
+|--------|------|------|----------|--------|
+| 견적관리 | `QuoteManagement.tsx` | 1,001줄 | O (경계선) | IntegratedListTemplateV2 |
+| 거래처관리 | `CustomerAccountManagement.tsx` | 425줄 | X | ListPageTemplate |
+
+---
+
+## 2. 견적관리 (`QuoteManagement.tsx`)
+
+### 2.1 파일 정보
+- **경로**: `sam-design/src/components/QuoteManagement.tsx`
+- **크기**: 1,001줄
+- **템플릿**: `IntegratedListTemplateV2`
+
+### 2.2 컴포넌트 구조
+```
+QuoteManagement
+├── IntegratedListTemplateV2 (목록 템플릿)
+│   ├── PageHeader (제목: "견적 목록")
+│   ├── StatCards (4개 통계 카드)
+│   │   ├── 이번 달 견적 금액
+│   │   ├── 진행중 견적 금액
+│   │   ├── 이번 주 신규 견적
+│   │   └── 이번 달 수주 전환율
+│   ├── SearchFilter (검색바)
+│   ├── TabChip 탭
+│   │   ├── 전체
+│   │   ├── 최초작성
+│   │   ├── 수정중
+│   │   ├── 최종확정
+│   │   └── 수주전환
+│   ├── DataTable (데스크톱 테이블)
+│   └── ListMobileCard (모바일 카드)
+├── QuoteManagement3Write (등록/수정 화면)
+├── QuoteManagement3Detail (상세 화면)
+├── QuoteDetailView (상세 화면 - 샘플용)
+└── StandardDialog (산출내역서/삭제 확인)
+```
+
+### 2.3 주요 기능
+- 목록 조회 (페이지네이션, 검색, 필터)
+- 탭 기반 상태 필터링
+- 체크박스 선택 + 일괄 삭제
+- 모바일 인피니티 스크롤
+- CRUD (등록/조회/수정/삭제)
+- 산출내역서 다이얼로그
+
+### 2.4 분할 제안
+```
+src/app/[locale]/(protected)/sales/quotes/
+├── page.tsx                    # 목록 (라우팅 + 상태 관리)
+├── components/
+│   ├── QuoteList.tsx          # 목록 컴포넌트
+│   ├── QuoteTableRow.tsx      # 테이블 행
+│   └── QuoteMobileCard.tsx    # 모바일 카드
+├── create/
+│   └── page.tsx               # 견적 등록
+├── [id]/
+│   ├── page.tsx               # 견적 상세
+│   └── edit/
+│       └── page.tsx           # 견적 수정
+```
+
+### 2.5 의존성 컴포넌트
+| 컴포넌트 | 경로 | 마이그레이션 필요 |
+|----------|------|------------------|
+| IntegratedListTemplateV2 | templates/ | O |
+| PageHeader | organisms/ | 이미 존재 |
+| PageLayout | organisms/ | 이미 존재 |
+| StatCards | organisms/ | O |
+| SearchFilter | organisms/ | O |
+| TabChip | atoms/ | O |
+| ListMobileCard | organisms/ | O |
+| DataTable | organisms/ | O |
+| StandardDialog | molecules/ | O |
+| QuoteManagement3Write | components/ | O (별도 분석 필요) |
+| QuoteManagement3Detail | components/ | O (별도 분석 필요) |
+
+---
+
+## 3. 거래처관리 (`CustomerAccountManagement.tsx`)
+
+### 3.1 파일 정보
+- **경로**: `sam-design/src/components/CustomerAccountManagement.tsx`
+- **크기**: 425줄
+- **템플릿**: `ListPageTemplate`
+
+### 3.2 컴포넌트 구조
+```
+CustomerAccountManagement
+├── ListPageTemplate (목록 템플릿)
+│   ├── PageHeader (제목: "매출처 목록")
+│   ├── StatCards (3개 통계 카드)
+│   │   ├── 전체 거래처
+│   │   ├── 활성 거래처
+│   │   └── 비활성 거래처
+│   ├── SearchFilter (검색바)
+│   ├── DataTable (데스크톱 테이블)
+│   │   └── columns: 코드, 거래처명, 사업자번호, 대표자, 전화번호, 업태, 업종, 상태, 관리
+│   └── MobileCard (모바일 카드)
+└── Dialog (등록/수정 모달)
+    └── FormFields: 거래처명, 사업자번호, 대표자, 전화번호, 주소, 이메일, 업태, 업종
+```
+
+### 3.3 주요 기능
+- 거래처 목록 조회 (검색)
+- CRUD (등록/수정/삭제)
+- 모달 기반 폼
+
+### 3.4 Next.js 구조 제안
+```
+src/app/[locale]/(protected)/sales/customers/
+├── page.tsx                    # 목록 + 모달 (425줄이라 단일 파일 가능)
+└── components/
+    └── CustomerForm.tsx        # 폼 분리 (선택)
+```
+
+### 3.5 의존성 컴포넌트
+| 컴포넌트 | 경로 | 마이그레이션 필요 |
+|----------|------|------------------|
+| ListPageTemplate | templates/ | O |
+| PageHeader | organisms/ | 이미 존재 |
+| PageLayout | organisms/ | 이미 존재 |
+| StatCards | organisms/ | O |
+| SearchFilter | organisms/ | O |
+| DataTable | organisms/ | O |
+| MobileCard | organisms/ | O |
+| Dialog | ui/ | 이미 존재 |
+
+---
+
+## 4. 공통 테이블 UI 기준 (중요)
+
+### 4.1 최종 기준: 견적관리 페이지 테이블
+
+> **공통 테이블 UI는 `QuoteManagement.tsx`의 테이블 형태를 최종 기준으로 적용**
+
+거래처관리를 포함한 모든 목록 페이지는 견적관리 페이지의 테이블 UI를 따릅니다.
+
+### 4.2 테이블 화면 구조
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ [PageHeader] 견적 목록                          [등록 버튼] │
+├─────────────────────────────────────────────────────────────┤
+│ [StatCards] 4개 통계 카드 (2x2 또는 4열)                    │
+├─────────────────────────────────────────────────────────────┤
+│ [SearchFilter] 검색바 + 추가 필터                           │
+├─────────────────────────────────────────────────────────────┤
+│ [TabChip] 전체 | 최초작성 | 수정중 | 최종확정 | 수주전환    │
+├───┬───────────────────────────────────────────────────┬─────┤
+│ ☐ │ 번호 | 견적번호 | 접수일 | 상태 | ... | 비고 | 작업   │
+├───┼───────────────────────────────────────────────────┼─────┤
+│ ☐ │ 10   | Q2024-001| 2024-01 | 진행 | ... | -    | [편집]│
+│ ☐ │ 9    | Q2024-002| 2024-01 | 확정 | ... | -    | [편집]│
+├───┴───────────────────────────────────────────────────┴─────┤
+│ [Pagination] 전체 100개 중 1-20개 표시   [이전] 1 2 3 [다음]│
+└─────────────────────────────────────────────────────────────┘
+```
+
+### 4.3 반응형 구조
+
+| 화면 크기 | 뷰 타입 | 특징 |
+|-----------|---------|------|
+| **데스크톱** (1280px+) | 테이블 뷰 | 체크박스 + 전체 컬럼 + 페이지네이션 |
+| **태블릿** (~1279px) | 카드 뷰 | 2~3열 그리드 + 인피니티 스크롤 |
+| **모바일** (~767px) | 카드 뷰 | 1열 + 인피니티 스크롤 |
+
+**반응형 전환 기준**:
+- `xl:` (1280px+) → 테이블 뷰
+- `md:` (768px~1279px) → 카드 그리드 (2~3열)
+- 기본 → 카드 단일 열
+
+### 4.4 테이블 기능 목록
+
+#### 필수 기능
+- [ ] **체크박스 선택**: 개별 선택 + 전체 선택
+- [ ] **일괄 삭제**: 2개 이상 선택 시 삭제 버튼 표시
+- [ ] **역순 번호**: totalCount 기준 역순 (최신이 1번이 아닌 N번)
+- [ ] **행 클릭**: 상세 페이지로 이동
+- [ ] **액션 버튼**: 선택된 행에만 수정/삭제 버튼 표시
+
+#### 페이지네이션 (데스크톱)
+- [ ] 페이지당 20개 표시
+- [ ] 현재 페이지 표시 (1-20 / 100개)
+- [ ] 이전/다음 버튼
+- [ ] 페이지 번호 (현재 ±2 범위)
+
+#### 인피니티 스크롤 (모바일/태블릿)
+- [ ] Intersection Observer 사용
+- [ ] 20개씩 추가 로드
+- [ ] Sentinel 요소로 트리거
+
+### 4.5 적용 대상
+
+| 페이지 | 적용 내용 |
+|--------|----------|
+| **견적관리** | 기준 페이지 (이미 적용됨) |
+| **거래처관리** | 동일한 테이블 UI 적용 필요 |
+| **향후 목록 페이지** | 모두 동일한 공통 테이블 UI 사용 |
+
+### 4.6 공통 테이블 컴포넌트 구조
+
+```
+공통 테이블 UI
+├── IntegratedListTemplateV2 (템플릿)
+│   ├── PageHeader
+│   ├── StatCards
+│   ├── SearchFilter
+│   ├── TabChip (선택적)
+│   ├── DataTable (데스크톱)
+│   │   ├── 체크박스 컬럼
+│   │   ├── 데이터 컬럼들
+│   │   ├── 액션 컬럼
+│   │   └── 페이지네이션
+│   └── ListMobileCard (모바일/태블릿)
+│       ├── 체크박스
+│       ├── 헤더 뱃지
+│       ├── 정보 그리드
+│       └── 액션 버튼 (선택 시)
+```
+
+---
+
+## 5. 공통 UI 컴포넌트 마이그레이션
+
+### 5.1 마이그레이션 필요 목록
+
+| 컴포넌트 | 소스 경로 | 타겟 경로 | 크기 | 우선순위 |
+|----------|----------|----------|------|----------|
+| StatCards | organisms/StatCards.tsx | organisms/ | 53줄 | P1 |
+| SearchFilter | organisms/SearchFilter.tsx | organisms/ | 54줄 | P1 |
+| DataTable | organisms/DataTable.tsx | organisms/ | 313줄 | P1 |
+| MobileCard | organisms/MobileCard.tsx | organisms/ | 104줄 | P1 |
+| ListMobileCard | organisms/ListMobileCard.tsx | organisms/ | 169줄 | P1 |
+| TabChip | atoms/TabChip.tsx | atoms/ | ~50줄 | P2 |
+| ListPageTemplate | templates/ListPageTemplate.tsx | templates/ | 143줄 | P2 |
+| IntegratedListTemplateV2 | templates/IntegratedListTemplateV2.tsx | templates/ | 491줄 | P2 |
+| StandardDialog | molecules/StandardDialog.tsx | molecules/ | ~150줄 | P3 |
+| InfoField | organisms/ListMobileCard.tsx | organisms/ | 8줄 | P1 |
+
+### 5.2 Next.js 타겟 구조
+```
+src/components/
+├── atoms/
+│   └── TabChip.tsx                 # NEW
+├── molecules/
+│   └── StandardDialog.tsx          # NEW
+├── organisms/
+│   ├── PageHeader.tsx              # 기존
+│   ├── PageLayout.tsx              # 기존
+│   ├── StatCards.tsx               # NEW
+│   ├── SearchFilter.tsx            # NEW
+│   ├── DataTable.tsx               # NEW
+│   ├── MobileCard.tsx              # NEW
+│   └── ListMobileCard.tsx          # NEW
+├── templates/
+│   ├── ListPageTemplate.tsx        # NEW
+│   └── IntegratedListTemplateV2.tsx # NEW
+└── ui/                             # 기존 (변경 없음)
+```
+
+### 5.3 컴포넌트 상세
+
+#### StatCards (53줄)
+```typescript
+interface StatCardData {
+  label: string;
+  value: string | number;
+  icon?: LucideIcon;
+  iconColor?: string;
+  trend?: { value: string; isPositive: boolean };
+}
+```
+- 2x2 또는 4열 그리드
+- 아이콘 + 라벨 + 값 + 트렌드
+
+#### SearchFilter (54줄)
+```typescript
+interface SearchFilterProps {
+  searchValue: string;
+  onSearchChange: (value: string) => void;
+  searchPlaceholder?: string;
+  filterButton?: boolean;
+  onFilterClick?: () => void;
+  extraActions?: ReactNode;
+}
+```
+- 검색 아이콘 + Input
+- 모바일 플레이스홀더 변경
+
+#### DataTable (313줄)
+```typescript
+interface Column<T> {
+  key: keyof T | string;
+  label: string;
+  type?: CellType; // text, number, currency, date, status, badge, actions, custom
+  render?: (value: any, row: T, index?: number) => ReactNode;
+}
+```
+- 타입별 셀 렌더링
+- 페이지네이션 지원
+- 로딩/빈 상태 처리
+
+#### ListMobileCard (169줄)
+```typescript
+interface ListMobileCardProps {
+  id: string;
+  isSelected: boolean;
+  onToggleSelection: () => void;
+  onCardClick?: () => void;
+  headerBadges?: ReactNode;
+  title: string;
+  statusBadge?: ReactNode;
+  infoGrid: ReactNode;
+  actions?: ReactNode;
+}
+```
+- 체크박스 포함
+- 선택 시 스타일 변경
+- InfoField 하위 컴포넌트
+
+---
+
+## 6. 작업 순서 (권장)
+
+### Phase 1: 공통 UI 컴포넌트 (선행) ✅ 완료
+- [x] StatCards 마이그레이션
+- [x] SearchFilter 마이그레이션
+- [x] DataTable 마이그레이션
+- [x] MobileCard 마이그레이션
+- [x] ListMobileCard + InfoField 마이그레이션
+- [x] TabChip 마이그레이션
+- [x] ListPageTemplate 마이그레이션
+- [x] IntegratedListTemplateV2 마이그레이션
+- [x] BadgeSm 마이그레이션 (추가)
+- [x] StatusBadge 마이그레이션 (추가)
+- [x] IconWithBadge 마이그레이션 (추가)
+- [x] TableActions 마이그레이션 (추가)
+- [x] EmptyState 마이그레이션 (추가)
+- [x] ScreenVersionHistory 마이그레이션 (추가)
+- [x] StandardDialog 마이그레이션 (추가)
+- [x] formatAmount 유틸리티 마이그레이션 (추가)
+
+### Phase 2: 거래처관리 (간단한 것 먼저) ✅ 완료
+- [x] 라우트 생성: `/sales/customers`
+- [x] CustomerAccountManagement 마이그레이션
+- [x] 테스트 및 검증 (빌드 통과)
+
+### Phase 3: 견적관리 (복잡한 것) ✅ 완료
+- [x] 라우트 생성: `/sales/quotes`
+- [x] QuoteManagement 목록 페이지 마이그레이션
+- [x] Separator 컴포넌트 추가 (의존성)
+- [x] 테스트 및 검증 (빌드 통과)
+- [ ] QuoteManagement3Write 분석 및 마이그레이션 (향후 작업)
+- [ ] QuoteManagement3Detail 분석 및 마이그레이션 (향후 작업)
+
+---
+
+## 7. 주의사항
+
+### 7.1 React → Next.js 마이그레이션 체크리스트
+- [ ] `'use client'` 디렉티브 추가 (상태/이벤트 사용 시)
+- [ ] `localStorage` 접근 시 `typeof window !== 'undefined'` 체크
+- [ ] `useRouter` → `next/navigation`으로 변경
+- [ ] 이미지 → `next/image` 사용
+- [ ] 링크 → `next/link` 사용
+
+### 6.2 스타일 호환성
+- sam-design: Tailwind CSS + shadcn/ui
+- sam-react-prod: Tailwind CSS + shadcn/ui (동일)
+- cn() 유틸리티 경로 확인 필요
+
+### 6.3 의존성 확인
+```bash
+# sam-design에서 사용하는 라이브러리
+- lucide-react
+- sonner (toast)
+- react-hook-form (폼)
+- zod (validation)
+```
+
+---
+
+## 7. 예상 작업량
+
+| 항목 | 예상 크기 |
+|------|----------|
+| 공통 UI 컴포넌트 | ~1,400줄 |
+| 거래처관리 | ~500줄 |
+| 견적관리 (분할 포함) | ~1,500줄+ |
+| **총합** | **~3,400줄+** |
+
+---
+
+## 8. 관련 파일 참조
+
+### sam-design 소스 파일
+```
+sam-design/sam-design/src/components/
+├── QuoteManagement.tsx
+├── CustomerAccountManagement.tsx
+├── atoms/
+│   └── TabChip.tsx
+├── molecules/
+│   └── StandardDialog.tsx
+├── organisms/
+│   ├── StatCards.tsx
+│   ├── SearchFilter.tsx
+│   ├── DataTable.tsx
+│   ├── MobileCard.tsx
+│   └── ListMobileCard.tsx
+└── templates/
+    ├── ListPageTemplate.tsx
+    └── IntegratedListTemplateV2.tsx
+```
+
+### Next.js 타겟 경로
+```
+sam-react-prod/src/
+├── app/[locale]/(protected)/sales/
+│   ├── quotes/
+│   │   └── page.tsx
+│   └── customers/
+│       └── page.tsx
+└── components/
+    ├── atoms/
+    ├── molecules/
+    ├── organisms/
+    └── templates/
+```
\ No newline at end of file
diff --git a/src/app/[locale]/(protected)/items/create/page.tsx b/src/app/[locale]/(protected)/items/create/page.tsx
index 021444de..731da73e 100644
--- a/src/app/[locale]/(protected)/items/create/page.tsx
+++ b/src/app/[locale]/(protected)/items/create/page.tsx
@@ -1,28 +1,61 @@
 /**
  * 품목 등록 페이지
+ *
+ * DynamicItemForm을 사용하여 품목기준관리 데이터 기반 동적 폼 렌더링
  */
 
 'use client';
 
-import ItemForm from '@/components/items/ItemForm';
-import type { CreateItemFormData } from '@/lib/utils/validation';
+import { useState } from 'react';
+import DynamicItemForm from '@/components/items/DynamicItemForm';
+import type { DynamicFormData } from '@/components/items/DynamicItemForm/types';
+
+// 기존 ItemForm (주석처리 - 롤백 시 사용)
+// import ItemForm from '@/components/items/ItemForm';
+// import type { CreateItemFormData } from '@/lib/utils/validation';
 
 export default function CreateItemPage() {
-  const handleSubmit = async (data: CreateItemFormData) => {
-    // TODO: API 연동 시 createItem() 호출
-    console.log('품목 등록 데이터:', data);
+  const [submitError, setSubmitError] = useState<string | null>(null);
 
-    // Mock: 성공 메시지
-    alert(`품목 "${data.itemName}" (${data.itemCode})이(가) 등록되었습니다.`);
+  const handleSubmit = async (data: DynamicFormData) => {
+    setSubmitError(null);
 
-    // API 연동 예시:
-    // const newItem = await createItem(data);
-    // router.push(`/items/${newItem.itemCode}`);
+    try {
+      // API 호출: POST /api/proxy/items
+      const response = await fetch('/api/proxy/items', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(data),
+      });
+
+      const result = await response.json();
+
+      if (!response.ok || !result.success) {
+        throw new Error(result.message || '품목 등록에 실패했습니다.');
+      }
+
+      // 성공 시 DynamicItemForm 내부에서 /items로 리다이렉트 처리됨
+      console.log('[CreateItemPage] 품목 등록 성공:', result.data);
+    } catch (error) {
+      console.error('[CreateItemPage] 품목 등록 실패:', error);
+      setSubmitError(error instanceof Error ? error.message : '품목 등록에 실패했습니다.');
+      throw error; // DynamicItemForm에서 에러 처리
+    }
   };
 
   return (
     <div className="py-6">
-      <ItemForm mode="create" onSubmit={handleSubmit} />
+      {submitError && (
+        <div className="mb-4 p-4 bg-red-50 border border-red-200 rounded-lg text-red-900">
+          ⚠️ {submitError}
+        </div>
+      )}
+      <DynamicItemForm
+        mode="create"
+        onSubmit={handleSubmit}
+      />
     </div>
   );
 }
\ No newline at end of file
diff --git a/src/app/[locale]/(protected)/items/page.tsx b/src/app/[locale]/(protected)/items/page.tsx
index b57528e6..6cc29fe5 100644
--- a/src/app/[locale]/(protected)/items/page.tsx
+++ b/src/app/[locale]/(protected)/items/page.tsx
@@ -1,154 +1,20 @@
 /**
- * 품목 목록 페이지 (Server Component)
+ * 품목 관리 페이지
  *
- * Next.js 15 App Router
- * 서버에서 데이터 fetching 후 Client Component로 전달
+ * 품목기준관리 API 연동
+ * - 품목 목록: API에서 조회
+ * - 테이블 컬럼: custom-tabs API에서 동적 구성
  */
 
-import { Suspense } from 'react';
 import ItemListClient from '@/components/items/ItemListClient';
-import type { ItemMaster } from '@/types/item';
-
-// Mock 데이터 (API 연동 전 임시)
-const mockItems: ItemMaster[] = [
-  {
-    id: '1',
-    itemCode: 'KD-FG-001',
-    itemName: '스크린 제품 A',
-    itemType: 'FG',
-    unit: 'EA',
-    specification: '2000x2000',
-    isActive: true,
-    category1: '본체부품',
-    category2: '가이드시스템',
-    salesPrice: 150000,
-    purchasePrice: 100000,
-    productCategory: 'SCREEN',
-    lotAbbreviation: 'KD',
-    currentRevision: 0,
-    isFinal: false,
-    createdAt: '2025-01-10T00:00:00Z',
-  },
-  {
-    id: '2',
-    itemCode: 'KD-PT-001',
-    itemName: '가이드레일(벽면형)',
-    itemType: 'PT',
-    unit: 'EA',
-    specification: '2438mm',
-    isActive: true,
-    category1: '본체부품',
-    category2: '가이드시스템',
-    category3: '가이드레일',
-    salesPrice: 50000,
-    purchasePrice: 35000,
-    partType: 'ASSEMBLY',
-    partUsage: 'GUIDE_RAIL',
-    installationType: '벽면형',
-    assemblyType: 'M',
-    assemblyLength: '2438',
-    currentRevision: 0,
-    isFinal: false,
-    createdAt: '2025-01-10T00:00:00Z',
-  },
-  {
-    id: '3',
-    itemCode: 'KD-PT-002',
-    itemName: '절곡품 샘플',
-    itemType: 'PT',
-    unit: 'EA',
-    specification: 'EGI 1.55T',
-    isActive: true,
-    partType: 'BENDING',
-    material: 'EGI 1.55T',
-    length: '2000',
-    salesPrice: 30000,
-    currentRevision: 0,
-    isFinal: false,
-    createdAt: '2025-01-10T00:00:00Z',
-  },
-  {
-    id: '4',
-    itemCode: 'KD-RM-001',
-    itemName: 'SPHC-SD',
-    itemType: 'RM',
-    unit: 'KG',
-    specification: '1.6T x 1219 x 2438',
-    isActive: true,
-    category1: '철강재',
-    purchasePrice: 1500,
-    material: 'SPHC-SD',
-    currentRevision: 0,
-    isFinal: false,
-    createdAt: '2025-01-10T00:00:00Z',
-  },
-  {
-    id: '5',
-    itemCode: 'KD-SM-001',
-    itemName: '볼트 M6x20',
-    itemType: 'SM',
-    unit: 'EA',
-    specification: 'M6x20',
-    isActive: true,
-    category1: '구조재/부속품',
-    category2: '볼트/너트',
-    purchasePrice: 50,
-    currentRevision: 0,
-    isFinal: false,
-    createdAt: '2025-01-10T00:00:00Z',
-  },
-  {
-    id: '6',
-    itemCode: 'KD-CS-001',
-    itemName: '절삭유',
-    itemType: 'CS',
-    unit: 'L',
-    specification: '20L',
-    isActive: true,
-    purchasePrice: 30000,
-    currentRevision: 0,
-    isFinal: false,
-    createdAt: '2025-01-10T00:00:00Z',
-  },
-  {
-    id: '7',
-    itemCode: 'KD-FG-002',
-    itemName: '철재 제품 B',
-    itemType: 'FG',
-    unit: 'SET',
-    specification: '3000x2500',
-    isActive: false,
-    category1: '본체부품',
-    salesPrice: 200000,
-    productCategory: 'STEEL',
-    lotAbbreviation: 'KD',
-    currentRevision: 0,
-    isFinal: false,
-    createdAt: '2025-01-09T00:00:00Z',
-  },
-];
-
-/**
- * 품목 목록 조회 함수
- * TODO: API 연동 시 fetchItems()로 교체
- */
-async function getItems(): Promise<ItemMaster[]> {
-  // API 연동 전 mock 데이터 반환
-  // const items = await fetchItems();
-  return mockItems;
-}
 
 /**
  * 품목 목록 페이지
  */
-export default async function ItemsPage() {
-  const items = await getItems();
-
+export default function ItemsPage() {
   return (
     <div className="p-6">
-      <Suspense fallback={<div className="text-center py-8">로딩 중...</div>}>
-        <ItemListClient items={items} />
-      </Suspense>
+      <ItemListClient />
     </div>
   );
 }
diff --git a/src/app/[locale]/(protected)/sales/client-management-sales-admin/page.tsx b/src/app/[locale]/(protected)/sales/client-management-sales-admin/page.tsx
new file mode 100644
index 00000000..1bb04ca7
--- /dev/null
+++ b/src/app/[locale]/(protected)/sales/client-management-sales-admin/page.tsx
@@ -0,0 +1,778 @@
+"use client";
+
+/**
+ * 거래처관리 - IntegratedListTemplateV2 적용
+ *
+ * 견적관리와 동일한 구조로 통일
+ * - PageHeader, StatCards, SearchFilter
+ * - 탭 기반 필터 (데스크톱: TabsList, 모바일: 커스텀 버튼)
+ * - 체크박스 포함 DataTable (Desktop)
+ * - 체크박스 포함 모바일 카드 (Mobile)
+ * - 페이지네이션 + 모바일 인피니티 스크롤
+ */
+
+import { useState, useRef, useEffect } from "react";
+import {
+  Building2,
+  Plus,
+  Edit,
+  Trash2,
+  Users,
+  CheckCircle,
+  XCircle,
+} from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+  IntegratedListTemplateV2,
+  TabOption,
+  TableColumn,
+} from "@/components/templates/IntegratedListTemplateV2";
+import { toast } from "sonner";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+  DialogFooter,
+} from "@/components/ui/dialog";
+import {
+  TableRow,
+  TableCell,
+} from "@/components/ui/table";
+import { Checkbox } from "@/components/ui/checkbox";
+import { ListMobileCard, InfoField } from "@/components/organisms/ListMobileCard";
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+
+// 거래처 타입
+interface CustomerAccount {
+  id: string;
+  code: string;
+  name: string;
+  businessNo: string;
+  representative: string;
+  phone: string;
+  address: string;
+  email: string;
+  businessType: string;
+  businessItem: string;
+  registeredDate: string;
+  status: "활성" | "비활성";
+}
+
+// 샘플 거래처 데이터
+const SAMPLE_CUSTOMERS: CustomerAccount[] = [
+  {
+    id: "1",
+    code: "C-001",
+    name: "ABC건설",
+    businessNo: "123-45-67890",
+    representative: "홍길동",
+    phone: "02-1234-5678",
+    address: "서울시 강남구 테헤란로 123",
+    email: "abc@company.com",
+    businessType: "건설업",
+    businessItem: "건축공사",
+    registeredDate: "2024-01-15",
+    status: "활성",
+  },
+  {
+    id: "2",
+    code: "C-002",
+    name: "삼성전자",
+    businessNo: "234-56-78901",
+    representative: "김대표",
+    phone: "02-2345-6789",
+    address: "서울시 서초구 서초대로 456",
+    email: "samsung@company.com",
+    businessType: "제조업",
+    businessItem: "전자제품",
+    registeredDate: "2024-02-20",
+    status: "활성",
+  },
+  {
+    id: "3",
+    code: "C-003",
+    name: "LG전자",
+    businessNo: "345-67-89012",
+    representative: "이사장",
+    phone: "02-3456-7890",
+    address: "서울시 영등포구 여의대로 789",
+    email: "lg@company.com",
+    businessType: "제조업",
+    businessItem: "가전제품",
+    registeredDate: "2024-03-10",
+    status: "활성",
+  },
+  {
+    id: "4",
+    code: "C-004",
+    name: "현대건설",
+    businessNo: "456-78-90123",
+    representative: "박부장",
+    phone: "02-4567-8901",
+    address: "서울시 종로구 종로 101",
+    email: "hyundai@company.com",
+    businessType: "건설업",
+    businessItem: "토목공사",
+    registeredDate: "2024-04-05",
+    status: "비활성",
+  },
+  {
+    id: "5",
+    code: "C-005",
+    name: "SK하이닉스",
+    businessNo: "567-89-01234",
+    representative: "최이사",
+    phone: "031-5678-9012",
+    address: "경기도 이천시 부발읍",
+    email: "skhynix@company.com",
+    businessType: "제조업",
+    businessItem: "반도체",
+    registeredDate: "2024-05-12",
+    status: "활성",
+  },
+];
+
+export default function CustomerAccountManagementPage() {
+  const [searchTerm, setSearchTerm] = useState("");
+  const [filterType, setFilterType] = useState("all");
+  const [selectedItems, setSelectedItems] = useState<Set<string>>(new Set());
+  const [currentPage, setCurrentPage] = useState(1);
+  const itemsPerPage = 20;
+
+  // 모달 상태
+  const [isModalOpen, setIsModalOpen] = useState(false);
+  const [editingCustomer, setEditingCustomer] = useState<CustomerAccount | null>(null);
+  const [formData, setFormData] = useState({
+    name: "",
+    businessNo: "",
+    representative: "",
+    phone: "",
+    address: "",
+    email: "",
+    businessType: "",
+    businessItem: "",
+  });
+
+  // 삭제 확인 다이얼로그 state
+  const [isDeleteDialogOpen, setIsDeleteDialogOpen] = useState(false);
+  const [deleteTargetId, setDeleteTargetId] = useState<string | null>(null);
+
+  // 일괄 삭제 확인 다이얼로그 state
+  const [isBulkDeleteDialogOpen, setIsBulkDeleteDialogOpen] = useState(false);
+
+  // 모바일 인피니티 스크롤 state
+  const [mobileDisplayCount, setMobileDisplayCount] = useState(20);
+  const sentinelRef = useRef<HTMLDivElement>(null);
+
+  // 로컬 데이터 state
+  const [customers, setCustomers] = useState<CustomerAccount[]>(SAMPLE_CUSTOMERS);
+
+  // 필터링
+  const filteredCustomers = customers
+    .filter((customer) => {
+      const searchLower = searchTerm.toLowerCase();
+      const matchesSearch =
+        !searchTerm ||
+        customer.name.toLowerCase().includes(searchLower) ||
+        customer.code.toLowerCase().includes(searchLower) ||
+        customer.representative.toLowerCase().includes(searchLower) ||
+        customer.phone.includes(searchTerm) ||
+        customer.businessNo.includes(searchTerm);
+
+      let matchesFilter = true;
+      if (filterType === "active") {
+        matchesFilter = customer.status === "활성";
+      } else if (filterType === "inactive") {
+        matchesFilter = customer.status === "비활성";
+      }
+
+      return matchesSearch && matchesFilter;
+    })
+    .sort((a, b) => {
+      return (
+        new Date(b.registeredDate).getTime() -
+        new Date(a.registeredDate).getTime()
+      );
+    });
+
+  // 페이지네이션
+  const totalPages = Math.ceil(filteredCustomers.length / itemsPerPage);
+  const paginatedCustomers = filteredCustomers.slice(
+    (currentPage - 1) * itemsPerPage,
+    currentPage * itemsPerPage
+  );
+
+  // 모바일용 인피니티 스크롤 데이터
+  const mobileCustomers = filteredCustomers.slice(0, mobileDisplayCount);
+
+  // Intersection Observer를 이용한 인피니티 스크롤
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    if (window.innerWidth >= 1280) return;
+
+    const observer = new IntersectionObserver(
+      (entries) => {
+        if (
+          entries[0].isIntersecting &&
+          mobileDisplayCount < filteredCustomers.length
+        ) {
+          setMobileDisplayCount((prev) =>
+            Math.min(prev + 20, filteredCustomers.length)
+          );
+        }
+      },
+      {
+        threshold: 0.1,
+        rootMargin: "100px",
+      }
+    );
+
+    if (sentinelRef.current) {
+      observer.observe(sentinelRef.current);
+    }
+
+    return () => {
+      observer.disconnect();
+    };
+  }, [mobileDisplayCount, filteredCustomers.length]);
+
+  // 탭이나 검색어 변경 시 모바일 표시 개수 초기화
+  useEffect(() => {
+    setMobileDisplayCount(20);
+  }, [searchTerm, filterType]);
+
+  // 통계
+  const totalCustomers = customers.length;
+  const activeCustomers = customers.filter((c) => c.status === "활성").length;
+  const inactiveCustomers = customers.filter((c) => c.status === "비활성").length;
+
+  const stats = [
+    {
+      label: "전체 거래처",
+      value: totalCustomers,
+      icon: Users,
+      iconColor: "text-blue-600",
+    },
+    {
+      label: "활성 거래처",
+      value: activeCustomers,
+      icon: CheckCircle,
+      iconColor: "text-green-600",
+    },
+    {
+      label: "비활성 거래처",
+      value: inactiveCustomers,
+      icon: XCircle,
+      iconColor: "text-gray-600",
+    },
+  ];
+
+  // 핸들러
+  const handleAddNew = () => {
+    setEditingCustomer(null);
+    setFormData({
+      name: "",
+      businessNo: "",
+      representative: "",
+      phone: "",
+      address: "",
+      email: "",
+      businessType: "",
+      businessItem: "",
+    });
+    setIsModalOpen(true);
+  };
+
+  const handleEdit = (customer: CustomerAccount) => {
+    setEditingCustomer(customer);
+    setFormData({
+      name: customer.name,
+      businessNo: customer.businessNo,
+      representative: customer.representative,
+      phone: customer.phone,
+      address: customer.address,
+      email: customer.email,
+      businessType: customer.businessType,
+      businessItem: customer.businessItem,
+    });
+    setIsModalOpen(true);
+  };
+
+  const handleSave = () => {
+    if (editingCustomer) {
+      setCustomers(
+        customers.map((c) =>
+          c.id === editingCustomer.id ? { ...c, ...formData } : c
+        )
+      );
+      toast.success("거래처 정보가 수정되었습니다");
+    } else {
+      const newCode = `C-${String(customers.length + 1).padStart(3, "0")}`;
+      const newCustomer: CustomerAccount = {
+        id: String(customers.length + 1),
+        code: newCode,
+        ...formData,
+        registeredDate: new Date().toISOString().split("T")[0],
+        status: "활성",
+      };
+      setCustomers([...customers, newCustomer]);
+      toast.success("새 거래처가 등록되었습니다");
+    }
+    setIsModalOpen(false);
+  };
+
+  const handleView = (customer: CustomerAccount) => {
+    toast.info(`상세보기: ${customer.name}`);
+  };
+
+  const handleDelete = (customerId: string) => {
+    setDeleteTargetId(customerId);
+    setIsDeleteDialogOpen(true);
+  };
+
+  const handleConfirmDelete = () => {
+    if (deleteTargetId) {
+      const customer = customers.find((c) => c.id === deleteTargetId);
+      setCustomers(customers.filter((c) => c.id !== deleteTargetId));
+      toast.success(`거래처가 삭제되었습니다${customer ? `: ${customer.name}` : ""}`);
+      setIsDeleteDialogOpen(false);
+      setDeleteTargetId(null);
+    }
+  };
+
+  // 체크박스 선택
+  const toggleSelection = (id: string) => {
+    const newSelection = new Set(selectedItems);
+    if (newSelection.has(id)) {
+      newSelection.delete(id);
+    } else {
+      newSelection.add(id);
+    }
+    setSelectedItems(newSelection);
+  };
+
+  const toggleSelectAll = () => {
+    if (
+      selectedItems.size === paginatedCustomers.length &&
+      paginatedCustomers.length > 0
+    ) {
+      setSelectedItems(new Set());
+    } else {
+      setSelectedItems(new Set(paginatedCustomers.map((c) => c.id)));
+    }
+  };
+
+  // 일괄 삭제
+  const handleBulkDelete = () => {
+    if (selectedItems.size === 0) {
+      toast.error("삭제할 항목을 선택해주세요");
+      return;
+    }
+    setIsBulkDeleteDialogOpen(true);
+  };
+
+  const handleConfirmBulkDelete = () => {
+    setCustomers(customers.filter((c) => !selectedItems.has(c.id)));
+    toast.success(`${selectedItems.size}개의 거래처가 삭제되었습니다`);
+    setSelectedItems(new Set());
+    setIsBulkDeleteDialogOpen(false);
+  };
+
+  // 상태 뱃지
+  const getStatusBadge = (status: "활성" | "비활성") => {
+    if (status === "활성") {
+      return (
+        <Badge variant="outline" className="bg-green-100 text-green-700 border-green-200">
+          활성
+        </Badge>
+      );
+    }
+    return (
+      <Badge variant="outline" className="bg-gray-100 text-gray-700 border-gray-200">
+        비활성
+      </Badge>
+    );
+  };
+
+  // 탭 구성
+  const tabs: TabOption[] = [
+    {
+      value: "all",
+      label: "전체",
+      count: customers.length,
+      color: "blue",
+    },
+    {
+      value: "active",
+      label: "활성",
+      count: activeCustomers,
+      color: "green",
+    },
+    {
+      value: "inactive",
+      label: "비활성",
+      count: inactiveCustomers,
+      color: "gray",
+    },
+  ];
+
+  // 테이블 컬럼 정의
+  const tableColumns: TableColumn[] = [
+    { key: "rowNumber", label: "번호", className: "px-4" },
+    { key: "code", label: "코드", className: "px-4" },
+    { key: "name", label: "거래처명", className: "px-4" },
+    { key: "businessNo", label: "사업자번호", className: "px-4" },
+    { key: "representative", label: "대표자", className: "px-4" },
+    { key: "phone", label: "전화번호", className: "px-4" },
+    { key: "businessType", label: "업태", className: "px-4" },
+    { key: "businessItem", label: "업종", className: "px-4" },
+    { key: "status", label: "상태", className: "px-4" },
+    { key: "actions", label: "작업", className: "px-4" },
+  ];
+
+  // 테이블 행 렌더링
+  const renderTableRow = (
+    customer: CustomerAccount,
+    index: number,
+    globalIndex: number
+  ) => {
+    const itemId = customer.id;
+    const isSelected = selectedItems.has(itemId);
+
+    return (
+      <TableRow
+        key={customer.id}
+        className={`cursor-pointer hover:bg-muted/50 ${isSelected ? "bg-blue-50" : ""}`}
+        onClick={() => handleView(customer)}
+      >
+        <TableCell onClick={(e) => e.stopPropagation()} className="text-center">
+          <Checkbox
+            checked={isSelected}
+            onCheckedChange={() => toggleSelection(itemId)}
+          />
+        </TableCell>
+        <TableCell>{globalIndex}</TableCell>
+        <TableCell>
+          <code className="text-xs bg-gray-100 text-gray-700 px-2 py-1 rounded font-mono">
+            {customer.code}
+          </code>
+        </TableCell>
+        <TableCell className="font-medium">{customer.name}</TableCell>
+        <TableCell>{customer.businessNo}</TableCell>
+        <TableCell>{customer.representative}</TableCell>
+        <TableCell>{customer.phone}</TableCell>
+        <TableCell>{customer.businessType}</TableCell>
+        <TableCell>{customer.businessItem}</TableCell>
+        <TableCell>{getStatusBadge(customer.status)}</TableCell>
+        <TableCell onClick={(e) => e.stopPropagation()}>
+          {isSelected && (
+            <div className="flex gap-1">
+              <Button
+                variant="ghost"
+                size="sm"
+                onClick={() => handleEdit(customer)}
+              >
+                <Edit className="h-4 w-4" />
+              </Button>
+              <Button
+                variant="ghost"
+                size="sm"
+                onClick={() => handleDelete(customer.id)}
+              >
+                <Trash2 className="h-4 w-4 text-red-500" />
+              </Button>
+            </div>
+          )}
+        </TableCell>
+      </TableRow>
+    );
+  };
+
+  // 모바일 카드 렌더링
+  const renderMobileCard = (
+    customer: CustomerAccount,
+    index: number,
+    globalIndex: number,
+    isSelected: boolean,
+    onToggle: () => void
+  ) => {
+    return (
+      <ListMobileCard
+        key={customer.id}
+        id={customer.id}
+        isSelected={isSelected}
+        onToggleSelection={onToggle}
+        onCardClick={() => handleView(customer)}
+        headerBadges={
+          <>
+            <Badge
+              variant="outline"
+              className="bg-gray-100 text-gray-700 font-mono text-xs"
+            >
+              #{globalIndex}
+            </Badge>
+            <code className="inline-block text-xs bg-gray-100 text-gray-700 px-2.5 py-0.5 rounded-md font-mono whitespace-nowrap">
+              {customer.code}
+            </code>
+          </>
+        }
+        title={customer.name}
+        statusBadge={getStatusBadge(customer.status)}
+        infoGrid={
+          <div className="grid grid-cols-2 gap-x-4 gap-y-3">
+            <InfoField label="사업자번호" value={customer.businessNo} />
+            <InfoField label="대표자" value={customer.representative} />
+            <InfoField label="전화번호" value={customer.phone} />
+            <InfoField label="이메일" value={customer.email || "-"} />
+            <InfoField label="업태" value={customer.businessType || "-"} />
+            <InfoField label="업종" value={customer.businessItem || "-"} />
+            <InfoField label="등록일" value={customer.registeredDate} />
+          </div>
+        }
+        actions={
+          <div className="flex gap-2 flex-wrap">
+            <Button
+              variant="default"
+              size="default"
+              className="flex-1 min-w-[100px] h-11"
+              onClick={(e) => {
+                e.stopPropagation();
+                handleEdit(customer);
+              }}
+            >
+              <Edit className="h-4 w-4 mr-2" />
+              수정
+            </Button>
+            <Button
+              variant="outline"
+              size="default"
+              className="flex-1 min-w-[100px] h-11 border-red-200 text-red-600 hover:border-red-300 bg-[rgba(255,255,255,0)]"
+              onClick={(e) => {
+                e.stopPropagation();
+                handleDelete(customer.id);
+              }}
+            >
+              <Trash2 className="h-4 w-4 mr-2" />
+              삭제
+            </Button>
+          </div>
+        }
+      />
+    );
+  };
+
+  return (
+    <>
+      <IntegratedListTemplateV2
+        title="거래처 목록"
+        description="거래처 정보 및 계정을 관리합니다"
+        icon={Building2}
+        headerActions={
+          <Button onClick={handleAddNew}>
+            <Plus className="w-4 h-4 mr-2" />
+            거래처 등록
+          </Button>
+        }
+        stats={stats}
+        searchValue={searchTerm}
+        onSearchChange={setSearchTerm}
+        searchPlaceholder="거래처명, 코드, 대표자, 전화번호, 사업자번호 검색..."
+        tabs={tabs}
+        activeTab={filterType}
+        onTabChange={(value) => {
+          setFilterType(value);
+          setCurrentPage(1);
+        }}
+        tableColumns={tableColumns}
+        tableTitle={`${tabs.find((t) => t.value === filterType)?.label || "전체"} (${filteredCustomers.length}개)`}
+        data={paginatedCustomers}
+        totalCount={filteredCustomers.length}
+        allData={mobileCustomers}
+        mobileDisplayCount={mobileDisplayCount}
+        infinityScrollSentinelRef={sentinelRef}
+        selectedItems={selectedItems}
+        onToggleSelection={toggleSelection}
+        onToggleSelectAll={toggleSelectAll}
+        onBulkDelete={handleBulkDelete}
+        getItemId={(customer) => customer.id}
+        renderTableRow={renderTableRow}
+        renderMobileCard={renderMobileCard}
+        pagination={{
+          currentPage,
+          totalPages,
+          totalItems: filteredCustomers.length,
+          itemsPerPage,
+          onPageChange: setCurrentPage,
+        }}
+      />
+
+      {/* 등록/수정 모달 */}
+      <Dialog open={isModalOpen} onOpenChange={setIsModalOpen}>
+        <DialogContent className="max-w-2xl">
+          <DialogHeader>
+            <DialogTitle>
+              {editingCustomer ? "거래처 수정" : "거래처 등록"}
+            </DialogTitle>
+            <DialogDescription>거래처 정보를 입력하세요</DialogDescription>
+          </DialogHeader>
+          <div className="grid grid-cols-2 gap-4 py-4 px-6">
+            <div className="space-y-2">
+              <Label htmlFor="name">거래처명 *</Label>
+              <Input
+                id="name"
+                value={formData.name}
+                onChange={(e) =>
+                  setFormData({ ...formData, name: e.target.value })
+                }
+                placeholder="ABC건설"
+              />
+            </div>
+            <div className="space-y-2">
+              <Label htmlFor="businessNo">사업자번호 *</Label>
+              <Input
+                id="businessNo"
+                value={formData.businessNo}
+                onChange={(e) =>
+                  setFormData({ ...formData, businessNo: e.target.value })
+                }
+                placeholder="123-45-67890"
+              />
+            </div>
+            <div className="space-y-2">
+              <Label htmlFor="representative">대표자 *</Label>
+              <Input
+                id="representative"
+                value={formData.representative}
+                onChange={(e) =>
+                  setFormData({ ...formData, representative: e.target.value })
+                }
+                placeholder="홍길동"
+              />
+            </div>
+            <div className="space-y-2">
+              <Label htmlFor="phone">전화번호 *</Label>
+              <Input
+                id="phone"
+                value={formData.phone}
+                onChange={(e) =>
+                  setFormData({ ...formData, phone: e.target.value })
+                }
+                placeholder="02-1234-5678"
+              />
+            </div>
+            <div className="space-y-2 col-span-2">
+              <Label htmlFor="address">주소 *</Label>
+              <Input
+                id="address"
+                value={formData.address}
+                onChange={(e) =>
+                  setFormData({ ...formData, address: e.target.value })
+                }
+                placeholder="서울시 강남구 테헤란로 123"
+              />
+            </div>
+            <div className="space-y-2">
+              <Label htmlFor="email">이메일</Label>
+              <Input
+                id="email"
+                type="email"
+                value={formData.email}
+                onChange={(e) =>
+                  setFormData({ ...formData, email: e.target.value })
+                }
+                placeholder="abc@company.com"
+              />
+            </div>
+            <div className="space-y-2">
+              <Label htmlFor="businessType">업태</Label>
+              <Input
+                id="businessType"
+                value={formData.businessType}
+                onChange={(e) =>
+                  setFormData({ ...formData, businessType: e.target.value })
+                }
+                placeholder="건설업"
+              />
+            </div>
+            <div className="space-y-2 col-span-2">
+              <Label htmlFor="businessItem">업종</Label>
+              <Input
+                id="businessItem"
+                value={formData.businessItem}
+                onChange={(e) =>
+                  setFormData({ ...formData, businessItem: e.target.value })
+                }
+                placeholder="건축공사"
+              />
+            </div>
+          </div>
+          <DialogFooter>
+            <Button variant="outline" onClick={() => setIsModalOpen(false)}>
+              취소
+            </Button>
+            <Button onClick={handleSave}>저장</Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+
+      {/* 삭제 확인 다이얼로그 */}
+      <AlertDialog open={isDeleteDialogOpen} onOpenChange={setIsDeleteDialogOpen}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>거래처 삭제 확인</AlertDialogTitle>
+            <AlertDialogDescription>
+              {deleteTargetId
+                ? `거래처: ${customers.find((c) => c.id === deleteTargetId)?.name || deleteTargetId}`
+                : ""}
+              <br />
+              이 거래처를 삭제하시겠습니까? 삭제된 데이터는 복구할 수 없습니다.
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>취소</AlertDialogCancel>
+            <AlertDialogAction onClick={handleConfirmDelete}>
+              삭제
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+
+      {/* 일괄 삭제 확인 다이얼로그 */}
+      <AlertDialog
+        open={isBulkDeleteDialogOpen}
+        onOpenChange={setIsBulkDeleteDialogOpen}
+      >
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>일괄 삭제 확인</AlertDialogTitle>
+            <AlertDialogDescription>
+              선택한 {selectedItems.size}개의 거래처를 삭제하시겠습니까?
+              <br />
+              삭제된 데이터는 복구할 수 없습니다.
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>취소</AlertDialogCancel>
+            <AlertDialogAction onClick={handleConfirmBulkDelete}>
+              삭제
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </>
+  );
+}
\ No newline at end of file
diff --git a/src/app/[locale]/(protected)/sales/quote-management/page.tsx b/src/app/[locale]/(protected)/sales/quote-management/page.tsx
new file mode 100644
index 00000000..3773cbc0
--- /dev/null
+++ b/src/app/[locale]/(protected)/sales/quote-management/page.tsx
@@ -0,0 +1,856 @@
+"use client";
+
+/**
+ * 견적관리 - IntegratedListTemplateV2 적용
+ *
+ * sam-design에서 마이그레이션된 견적 관리 페이지
+ * - PageHeader, StatCards, SearchFilter, 체크박스
+ * - 데스크톱: TabsList + DataTable
+ * - 모바일: 커스텀 버튼 탭 + 카드 리스트
+ * - 완전한 반응형 지원
+ */
+
+import { useState, useRef, useEffect } from "react";
+import {
+  FileText,
+  Edit,
+  Trash2,
+  CheckCircle,
+  History,
+  Calculator,
+} from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { BadgeSm, getQuoteStatusBadge } from "@/components/atoms/BadgeSm";
+import {
+  IntegratedListTemplateV2,
+  TabOption,
+  TableColumn,
+} from "@/components/templates/IntegratedListTemplateV2";
+import { toast } from "sonner";
+import { StandardDialog } from "@/components/molecules/StandardDialog";
+import {
+  Table,
+  TableHeader,
+  TableRow,
+  TableHead,
+  TableBody,
+  TableCell,
+} from "@/components/ui/table";
+import { Separator } from "@/components/ui/separator";
+import { Checkbox } from "@/components/ui/checkbox";
+import { formatAmount, formatAmountManwon } from "@/utils/formatAmount";
+import { ListMobileCard, InfoField } from "@/components/organisms/ListMobileCard";
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+
+// 견적 타입
+interface Quote {
+  id: string;
+  quoteNumber: string;
+  registrationDate: string;
+  client: string;
+  site?: string;
+  siteCode?: string;
+  manager?: string;
+  contact?: string;
+  productCode?: string;
+  quantity: number;
+  amount: number;
+  status: "draft" | "converted";
+  currentRevision: number;
+  isFinal: boolean;
+  type?: string;
+  remarks?: string;
+}
+
+// 샘플 견적 데이터
+const SAMPLE_QUOTES: Quote[] = [
+  {
+    id: "SAMPLE-Q-001",
+    quoteNumber: "Q2024-001",
+    registrationDate: "2024-01-15",
+    client: "ABC건설",
+    site: "강남 오피스텔 현장",
+    siteCode: "PJ-20240115-01",
+    manager: "김철수",
+    contact: "010-1234-5678",
+    productCode: "SCR-001",
+    quantity: 10,
+    amount: 15000000,
+    status: "draft",
+    currentRevision: 0,
+    isFinal: false,
+    type: "스크린",
+    remarks: "급하게 진행 필요",
+  },
+  {
+    id: "SAMPLE-Q-002",
+    quoteNumber: "Q2024-002",
+    registrationDate: "2024-01-16",
+    client: "XYZ산업",
+    site: "판교 공장",
+    siteCode: "PJ-20240116-01",
+    manager: "이영희",
+    contact: "010-2345-6789",
+    productCode: "STL-002",
+    quantity: 5,
+    amount: 8500000,
+    status: "draft",
+    currentRevision: 2,
+    isFinal: false,
+    type: "철재",
+    remarks: "",
+  },
+  {
+    id: "SAMPLE-Q-003",
+    quoteNumber: "Q2024-003",
+    registrationDate: "2024-01-17",
+    client: "DEF개발",
+    site: "송도 아파트 현장",
+    siteCode: "PJ-20240117-01",
+    manager: "박민수",
+    contact: "010-3456-7890",
+    productCode: "SCR-003",
+    quantity: 20,
+    amount: 25000000,
+    status: "draft",
+    currentRevision: 0,
+    isFinal: true,
+    type: "스크린",
+    remarks: "확정 완료",
+  },
+  {
+    id: "SAMPLE-Q-004",
+    quoteNumber: "Q2024-004",
+    registrationDate: "2024-01-18",
+    client: "GHI건축",
+    site: "분당 상가 현장",
+    siteCode: "PJ-20240118-01",
+    manager: "최지원",
+    contact: "010-4567-8901",
+    productCode: "STL-004",
+    quantity: 8,
+    amount: 12000000,
+    status: "converted",
+    currentRevision: 1,
+    isFinal: true,
+    type: "철재",
+    remarks: "수주 전환 완료",
+  },
+  {
+    id: "SAMPLE-Q-005",
+    quoteNumber: "Q2024-005",
+    registrationDate: "2024-01-19",
+    client: "JKL개발",
+    site: "용산 오피스빌딩",
+    siteCode: "PJ-20240119-01",
+    manager: "정수민",
+    contact: "010-5678-9012",
+    productCode: "SCR-005",
+    quantity: 15,
+    amount: 22000000,
+    status: "draft",
+    currentRevision: 3,
+    isFinal: false,
+    type: "스크린",
+    remarks: "3차 수정 중",
+  },
+];
+
+export default function QuoteManagementPage() {
+  const [searchTerm, setSearchTerm] = useState("");
+  const [filterType, setFilterType] = useState("all");
+  const [isCalculationDialogOpen, setIsCalculationDialogOpen] = useState(false);
+  const [calculationQuote, setCalculationQuote] = useState<Quote | null>(null);
+  const [selectedItems, setSelectedItems] = useState<Set<string>>(new Set());
+  const [currentPage, setCurrentPage] = useState(1);
+  const itemsPerPage = 20;
+
+  // 삭제 확인 다이얼로그 state
+  const [isDeleteDialogOpen, setIsDeleteDialogOpen] = useState(false);
+  const [deleteTargetId, setDeleteTargetId] = useState<string | null>(null);
+
+  // 일괄 삭제 확인 다이얼로그 state
+  const [isBulkDeleteDialogOpen, setIsBulkDeleteDialogOpen] = useState(false);
+
+  // 모바일 인피니티 스크롤 state
+  const [mobileDisplayCount, setMobileDisplayCount] = useState(20);
+  const sentinelRef = useRef<HTMLDivElement>(null);
+
+  // 로컬 데이터 state (실제 구현에서는 API 연동)
+  const [quotes, setQuotes] = useState<Quote[]>(SAMPLE_QUOTES);
+
+  // 필터링 및 정렬
+  const filteredQuotes = quotes
+    .filter((quote) => {
+      const searchLower = searchTerm.toLowerCase();
+      const matchesSearch =
+        !searchTerm ||
+        quote.quoteNumber.toLowerCase().includes(searchLower) ||
+        quote.client.toLowerCase().includes(searchLower) ||
+        (quote.manager && quote.manager.toLowerCase().includes(searchLower)) ||
+        (quote.productCode &&
+          quote.productCode.toLowerCase().includes(searchLower)) ||
+        (quote.site && quote.site.toLowerCase().includes(searchLower));
+
+      let matchesFilter = true;
+      if (filterType === "initial") {
+        matchesFilter =
+          quote.currentRevision === 0 &&
+          !quote.isFinal &&
+          quote.status !== "converted";
+      } else if (filterType === "revising") {
+        matchesFilter =
+          quote.currentRevision > 0 &&
+          !quote.isFinal &&
+          quote.status !== "converted";
+      } else if (filterType === "final") {
+        matchesFilter = quote.isFinal && quote.status !== "converted";
+      } else if (filterType === "converted") {
+        matchesFilter = quote.status === "converted";
+      }
+
+      return matchesSearch && matchesFilter;
+    })
+    .sort((a, b) => {
+      return (
+        new Date(b.registrationDate).getTime() -
+        new Date(a.registrationDate).getTime()
+      );
+    });
+
+  // 페이지네이션
+  const totalPages = Math.ceil(filteredQuotes.length / itemsPerPage);
+  const paginatedQuotes = filteredQuotes.slice(
+    (currentPage - 1) * itemsPerPage,
+    currentPage * itemsPerPage
+  );
+
+  // 모바일용 인피니티 스크롤 데이터
+  const mobileQuotes = filteredQuotes.slice(0, mobileDisplayCount);
+
+  // Intersection Observer를 이용한 인피니티 스크롤
+  useEffect(() => {
+    // SSR 체크
+    if (typeof window === "undefined") return;
+
+    // 모바일/태블릿 환경(xl 미만)에서만 작동
+    if (window.innerWidth >= 1280) return;
+
+    const observer = new IntersectionObserver(
+      (entries) => {
+        // sentinel 요소가 화면에 보이고, 더 불러올 데이터가 있으면
+        if (
+          entries[0].isIntersecting &&
+          mobileDisplayCount < filteredQuotes.length
+        ) {
+          setMobileDisplayCount((prev) =>
+            Math.min(prev + 20, filteredQuotes.length)
+          );
+        }
+      },
+      {
+        threshold: 0.1, // 10%만 보여도 트리거
+        rootMargin: "100px", // 하단 100px 전에 미리 로드
+      }
+    );
+
+    if (sentinelRef.current) {
+      observer.observe(sentinelRef.current);
+    }
+
+    return () => {
+      observer.disconnect();
+    };
+  }, [mobileDisplayCount, filteredQuotes.length]);
+
+  // 탭이나 검색어 변경 시 모바일 표시 개수 초기화
+  useEffect(() => {
+    setMobileDisplayCount(20);
+  }, [searchTerm, filterType]);
+
+  // 통계 계산
+  const now = new Date();
+  const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+  const startOfWeek = new Date(now);
+  startOfWeek.setDate(now.getDate() - now.getDay()); // 이번 주 일요일
+
+  // 이번 달 견적 금액
+  const thisMonthQuotes = quotes.filter(
+    (q) => new Date(q.registrationDate) >= startOfMonth
+  );
+  const thisMonthAmount = thisMonthQuotes.reduce((sum, q) => sum + q.amount, 0);
+
+  // 진행중 견적 금액 (status === "draft")
+  const ongoingQuotes = quotes.filter((q) => q.status === "draft");
+  const ongoingAmount = ongoingQuotes.reduce((sum, q) => sum + q.amount, 0);
+
+  // 이번 주 신규 견적
+  const thisWeekQuotes = quotes.filter(
+    (q) => new Date(q.registrationDate) >= startOfWeek
+  );
+
+  // 이번 달 수주 전환율 (이번 달 등록된 견적 중 수주로 전환된 비율)
+  const thisMonthConvertedCount = thisMonthQuotes.filter(
+    (q) => q.status === "converted"
+  ).length;
+  const thisMonthConversionRate =
+    thisMonthQuotes.length > 0
+      ? ((thisMonthConvertedCount / thisMonthQuotes.length) * 100).toFixed(1)
+      : "0.0";
+
+  const stats = [
+    {
+      label: "이번 달 견적 금액",
+      value: formatAmountManwon(thisMonthAmount),
+      icon: Calculator,
+      iconColor: "text-blue-600",
+    },
+    {
+      label: "진행중 견적 금액",
+      value: formatAmountManwon(ongoingAmount),
+      icon: FileText,
+      iconColor: "text-orange-600",
+    },
+    {
+      label: "이번 주 신규 견적",
+      value: `${thisWeekQuotes.length}건`,
+      icon: Edit,
+      iconColor: "text-green-600",
+    },
+    {
+      label: "이번 달 수주 전환율",
+      value: `${thisMonthConversionRate}%`,
+      icon: CheckCircle,
+      iconColor: "text-purple-600",
+    },
+  ];
+
+  // 핸들러
+  const handleView = (quote: Quote) => {
+    toast.info(`상세보기: ${quote.quoteNumber}`);
+  };
+
+  const handleEdit = (quote: Quote) => {
+    toast.info(`수정: ${quote.quoteNumber}`);
+  };
+
+  const handleDelete = (quoteId: string) => {
+    setDeleteTargetId(quoteId);
+    setIsDeleteDialogOpen(true);
+  };
+
+  // 삭제 확인 후 실행
+  const handleConfirmDelete = () => {
+    if (deleteTargetId) {
+      const quote = quotes.find((q) => q.id === deleteTargetId);
+      setQuotes(quotes.filter((q) => q.id !== deleteTargetId));
+      toast.success(
+        `견적이 삭제되었습니다${quote ? `: ${quote.quoteNumber}` : ""}`
+      );
+      setIsDeleteDialogOpen(false);
+      setDeleteTargetId(null);
+    }
+  };
+
+  const handleViewHistory = (quote: Quote) => {
+    toast.info(`수정 이력: ${quote.quoteNumber} (${quote.currentRevision}차 수정)`);
+  };
+
+  const handleViewCalculation = (quote: Quote) => {
+    setCalculationQuote(quote);
+    setIsCalculationDialogOpen(true);
+  };
+
+  // 체크박스 선택
+  const toggleSelection = (id: string) => {
+    const newSelection = new Set(selectedItems);
+    if (newSelection.has(id)) {
+      newSelection.delete(id);
+    } else {
+      newSelection.add(id);
+    }
+    setSelectedItems(newSelection);
+  };
+
+  const toggleSelectAll = () => {
+    if (
+      selectedItems.size === paginatedQuotes.length &&
+      paginatedQuotes.length > 0
+    ) {
+      setSelectedItems(new Set());
+    } else {
+      setSelectedItems(new Set(paginatedQuotes.map((q) => q.id)));
+    }
+  };
+
+  // 일괄 삭제
+  const handleBulkDelete = () => {
+    if (selectedItems.size === 0) {
+      toast.error("삭제할 항목을 선택해주세요");
+      return;
+    }
+    setIsBulkDeleteDialogOpen(true);
+  };
+
+  const handleConfirmBulkDelete = () => {
+    setQuotes(quotes.filter((q) => !selectedItems.has(q.id)));
+    toast.success(`${selectedItems.size}개의 견적이 삭제되었습니다`);
+    setSelectedItems(new Set());
+    setIsBulkDeleteDialogOpen(false);
+  };
+
+  // 상태 뱃지
+  const getRevisionBadge = (quote: Quote) => {
+    return getQuoteStatusBadge(quote);
+  };
+
+  // 탭 구성
+  const tabs: TabOption[] = [
+    {
+      value: "all",
+      label: "전체",
+      count: quotes.length,
+      color: "blue",
+    },
+    {
+      value: "initial",
+      label: "최초작성",
+      count: quotes.filter(
+        (q) =>
+          q.currentRevision === 0 && !q.isFinal && q.status !== "converted"
+      ).length,
+      color: "gray",
+    },
+    {
+      value: "revising",
+      label: "수정중",
+      count: quotes.filter(
+        (q) =>
+          q.currentRevision > 0 && !q.isFinal && q.status !== "converted"
+      ).length,
+      color: "orange",
+    },
+    {
+      value: "final",
+      label: "최종확정",
+      count: quotes.filter((q) => q.isFinal && q.status !== "converted").length,
+      color: "green",
+    },
+    {
+      value: "converted",
+      label: "수주전환",
+      count: quotes.filter((q) => q.status === "converted").length,
+      color: "purple",
+    },
+  ];
+
+  // 테이블 컬럼 정의
+  const tableColumns: TableColumn[] = [
+    { key: "rowNumber", label: "번호", className: "px-4" },
+    { key: "quoteNumber", label: "견적번호", className: "px-4" },
+    { key: "registrationDate", label: "접수일", className: "px-4" },
+    { key: "status", label: "상태", className: "px-4" },
+    { key: "productName", label: "제품명", className: "px-4" },
+    { key: "quantity", label: "수량", className: "px-4" },
+    { key: "amount", label: "금액", className: "px-4" },
+    { key: "client", label: "발주처", className: "px-4" },
+    { key: "site", label: "현장명", className: "px-4" },
+    { key: "manager", label: "담당자", className: "px-4" },
+    { key: "remarks", label: "비고", className: "px-4" },
+    { key: "actions", label: "작업", className: "px-4" },
+  ];
+
+  // 테이블 행 렌더링
+  const renderTableRow = (
+    quote: Quote,
+    index: number,
+    globalIndex: number
+  ) => {
+    const itemId = quote.id;
+    const isSelected = selectedItems.has(itemId);
+
+    return (
+      <TableRow
+        key={quote.id}
+        className={`cursor-pointer hover:bg-muted/50 ${isSelected ? "bg-blue-50" : ""}`}
+        onClick={() => handleView(quote)}
+      >
+        <TableCell onClick={(e) => e.stopPropagation()} className="text-center">
+          <Checkbox
+            checked={isSelected}
+            onCheckedChange={() => toggleSelection(itemId)}
+          />
+        </TableCell>
+        <TableCell>{globalIndex}</TableCell>
+        <TableCell>
+          <code className="text-xs bg-gray-100 text-gray-700 px-2 py-1 rounded font-mono">
+            {quote.quoteNumber || "-"}
+          </code>
+        </TableCell>
+        <TableCell>{quote.registrationDate}</TableCell>
+        <TableCell>{getRevisionBadge(quote)}</TableCell>
+        <TableCell>{quote.productCode || "-"}</TableCell>
+        <TableCell className="text-center">{quote.quantity}</TableCell>
+        <TableCell className="text-right">{formatAmount(quote.amount)}</TableCell>
+        <TableCell>{quote.client}</TableCell>
+        <TableCell>
+          <div className="flex flex-col gap-1">
+            <span>{quote.site || "-"}</span>
+            {quote.siteCode && (
+              <code className="inline-block w-fit text-xs bg-gray-100 text-gray-700 px-1.5 py-0.5 rounded font-mono whitespace-nowrap">
+                {quote.siteCode}
+              </code>
+            )}
+          </div>
+        </TableCell>
+        <TableCell>{quote.manager || "-"}</TableCell>
+        <TableCell>
+          <div className="max-w-[200px] line-clamp-2 text-sm">
+            {quote.remarks || "-"}
+          </div>
+        </TableCell>
+        <TableCell onClick={(e) => e.stopPropagation()}>
+          {isSelected && (
+            <div className="flex gap-1">
+              {quote.currentRevision > 0 && (
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  onClick={() => handleViewHistory(quote)}
+                >
+                  <History className="h-4 w-4" />
+                </Button>
+              )}
+              <Button
+                variant="ghost"
+                size="sm"
+                onClick={() => handleEdit(quote)}
+              >
+                <Edit className="h-4 w-4" />
+              </Button>
+              {!quote.isFinal && (
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  onClick={() => handleDelete(quote.id)}
+                >
+                  <Trash2 className="h-4 w-4 text-red-500" />
+                </Button>
+              )}
+            </div>
+          )}
+        </TableCell>
+      </TableRow>
+    );
+  };
+
+  // 모바일 카드 렌더링
+  const renderMobileCard = (
+    quote: Quote,
+    index: number,
+    globalIndex: number,
+    isSelected: boolean,
+    onToggle: () => void
+  ) => {
+    return (
+      <ListMobileCard
+        key={quote.id}
+        id={quote.id}
+        isSelected={isSelected}
+        onToggleSelection={onToggle}
+        onCardClick={() => handleView(quote)}
+        headerBadges={
+          <>
+            <Badge
+              variant="outline"
+              className="bg-gray-100 text-gray-700 font-mono text-xs"
+            >
+              #{globalIndex}
+            </Badge>
+            <code className="inline-block text-xs bg-gray-100 text-gray-700 px-2.5 py-0.5 rounded-md font-mono whitespace-nowrap">
+              {quote.quoteNumber}
+            </code>
+          </>
+        }
+        title={quote.client}
+        statusBadge={getRevisionBadge(quote)}
+        infoGrid={
+          <div className="grid grid-cols-2 gap-x-4 gap-y-3">
+            <InfoField label="현장명" value={quote.site || "-"} />
+            <InfoField label="현장코드" value={quote.siteCode || "-"} />
+            <InfoField label="접수일" value={quote.registrationDate} />
+            <InfoField label="담당자" value={quote.manager || "-"} />
+            <InfoField label="제품명" value={quote.productCode || "-"} />
+            <InfoField label="수량" value={`${quote.quantity}개`} />
+            <InfoField
+              label="총 금액"
+              value={formatAmount(quote.amount)}
+              valueClassName="text-green-600"
+            />
+          </div>
+        }
+        actions={
+          <div className="flex gap-2 flex-wrap">
+            {quote.currentRevision > 0 && (
+              <Button
+                variant="outline"
+                size="default"
+                className="flex-1 min-w-[100px] h-11"
+                onClick={(e) => {
+                  e.stopPropagation();
+                  handleViewHistory(quote);
+                }}
+              >
+                <History className="h-4 w-4 mr-2" />
+                이력
+              </Button>
+            )}
+            <Button
+              variant="default"
+              size="default"
+              className="flex-1 min-w-[100px] h-11"
+              onClick={(e) => {
+                e.stopPropagation();
+                handleEdit(quote);
+              }}
+            >
+              <Edit className="h-4 w-4 mr-2" />
+              수정
+            </Button>
+            {!quote.isFinal && (
+              <Button
+                variant="outline"
+                size="default"
+                className="flex-1 min-w-[100px] h-11 border-red-200 text-red-600 hover:border-red-300 bg-[rgba(255,255,255,0)]"
+                onClick={(e) => {
+                  e.stopPropagation();
+                  handleDelete(quote.id);
+                }}
+              >
+                <Trash2 className="h-4 w-4 mr-2" />
+                삭제
+              </Button>
+            )}
+          </div>
+        }
+      />
+    );
+  };
+
+  // 목록 화면 - IntegratedListTemplateV2 사용
+  return (
+    <>
+      <IntegratedListTemplateV2
+        title="견적 목록"
+        description="견적서 작성 및 관리"
+        icon={FileText}
+        headerActions={
+          <Button onClick={() => toast.info("견적 등록 기능 준비중")}>
+            <FileText className="w-4 h-4 mr-2" />
+            견적 등록
+          </Button>
+        }
+        stats={stats}
+        searchValue={searchTerm}
+        onSearchChange={setSearchTerm}
+        searchPlaceholder="견적번호, 발주처, 담당자, 제품명, 현장코드, 현장명 검색..."
+        tabs={tabs}
+        activeTab={filterType}
+        onTabChange={(value) => {
+          setFilterType(value);
+          setCurrentPage(1);
+        }}
+        tableColumns={tableColumns}
+        tableTitle={`${tabs.find((t) => t.value === filterType)?.label || "전체"} (${filteredQuotes.length}개)`}
+        data={paginatedQuotes}
+        totalCount={filteredQuotes.length}
+        allData={mobileQuotes}
+        mobileDisplayCount={mobileDisplayCount}
+        infinityScrollSentinelRef={sentinelRef}
+        selectedItems={selectedItems}
+        onToggleSelection={toggleSelection}
+        onToggleSelectAll={toggleSelectAll}
+        onBulkDelete={handleBulkDelete}
+        getItemId={(quote) => quote.id}
+        renderTableRow={renderTableRow}
+        renderMobileCard={renderMobileCard}
+        pagination={{
+          currentPage,
+          totalPages,
+          totalItems: filteredQuotes.length,
+          itemsPerPage,
+          onPageChange: setCurrentPage,
+        }}
+      />
+
+      {/* 산출내역서 다이얼로그 */}
+      <StandardDialog
+        open={isCalculationDialogOpen}
+        onOpenChange={setIsCalculationDialogOpen}
+        title="산출내역서"
+        description={
+          calculationQuote
+            ? `견적번호: ${calculationQuote.quoteNumber} | 발주처: ${calculationQuote.client}`
+            : ""
+        }
+        size="xl"
+        footer={
+          <Button onClick={() => setIsCalculationDialogOpen(false)}>닫기</Button>
+        }
+      >
+        {calculationQuote && (
+          <div className="space-y-6">
+            {/* 기본 정보 */}
+            <div className="grid grid-cols-2 md:grid-cols-4 gap-4 p-4 bg-muted/50 rounded-lg">
+              <div>
+                <p className="text-sm text-muted-foreground">견적번호</p>
+                <p className="font-medium">{calculationQuote.quoteNumber}</p>
+              </div>
+              <div>
+                <p className="text-sm text-muted-foreground">발주처</p>
+                <p className="font-medium">{calculationQuote.client}</p>
+              </div>
+              <div>
+                <p className="text-sm text-muted-foreground">현장명</p>
+                <p className="font-medium">{calculationQuote.site || "-"}</p>
+              </div>
+              <div>
+                <p className="text-sm text-muted-foreground">접수일</p>
+                <p className="font-medium">
+                  {calculationQuote.registrationDate}
+                </p>
+              </div>
+            </div>
+
+            <Separator />
+
+            {/* 산출 내역 테이블 */}
+            <div>
+              <h4 className="font-semibold mb-3 flex items-center gap-2">
+                <Calculator className="w-5 h-5" />
+                산출 내역
+              </h4>
+              <div className="border rounded-lg overflow-hidden">
+                <Table>
+                  <TableHeader>
+                    <TableRow>
+                      <TableHead className="w-[60px]">번호</TableHead>
+                      <TableHead>품목명</TableHead>
+                      <TableHead>규격</TableHead>
+                      <TableHead className="text-center">수량</TableHead>
+                      <TableHead className="text-right">단가</TableHead>
+                      <TableHead className="text-right">공급가</TableHead>
+                      <TableHead className="text-right">부가세</TableHead>
+                      <TableHead className="text-right">합계</TableHead>
+                    </TableRow>
+                  </TableHeader>
+                  <TableBody>
+                    <TableRow>
+                      <TableCell>1</TableCell>
+                      <TableCell>{calculationQuote.type || "스크린"}</TableCell>
+                      <TableCell>{calculationQuote.productCode || "-"}</TableCell>
+                      <TableCell className="text-center">
+                        {calculationQuote.quantity}
+                      </TableCell>
+                      <TableCell className="text-right">
+                        {formatAmount(
+                          Math.floor(
+                            calculationQuote.amount / calculationQuote.quantity
+                          )
+                        )}
+                        원
+                      </TableCell>
+                      <TableCell className="text-right">
+                        {formatAmount(
+                          Math.floor(calculationQuote.amount / 1.1)
+                        )}
+                        원
+                      </TableCell>
+                      <TableCell className="text-right">
+                        {formatAmount(
+                          Math.floor(
+                            calculationQuote.amount -
+                              calculationQuote.amount / 1.1
+                          )
+                        )}
+                        원
+                      </TableCell>
+                      <TableCell className="text-right font-medium">
+                        {formatAmount(calculationQuote.amount)}원
+                      </TableCell>
+                    </TableRow>
+                  </TableBody>
+                </Table>
+              </div>
+            </div>
+
+            {/* 합계 */}
+            <div className="bg-muted/50 p-4 rounded-lg">
+              <div className="flex justify-between items-center">
+                <span className="font-semibold">총 금액</span>
+                <span className="text-xl font-bold text-primary">
+                  {formatAmount(calculationQuote.amount)}원
+                </span>
+              </div>
+            </div>
+          </div>
+        )}
+      </StandardDialog>
+
+      {/* 삭제 확인 다이얼로그 */}
+      <AlertDialog open={isDeleteDialogOpen} onOpenChange={setIsDeleteDialogOpen}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>견적 삭제 확인</AlertDialogTitle>
+            <AlertDialogDescription>
+              {deleteTargetId
+                ? `견적번호: ${quotes.find((q) => q.id === deleteTargetId)?.quoteNumber || deleteTargetId}`
+                : ""}
+              <br />
+              이 견적을 삭제하시겠습니까? 삭제된 데이터는 복구할 수 없습니다.
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>취소</AlertDialogCancel>
+            <AlertDialogAction onClick={handleConfirmDelete}>
+              삭제
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+
+      {/* 일괄 삭제 확인 다이얼로그 */}
+      <AlertDialog
+        open={isBulkDeleteDialogOpen}
+        onOpenChange={setIsBulkDeleteDialogOpen}
+      >
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>일괄 삭제 확인</AlertDialogTitle>
+            <AlertDialogDescription>
+              선택한 {selectedItems.size}개의 견적을 삭제하시겠습니까?
+              <br />
+              삭제된 데이터는 복구할 수 없습니다.
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>취소</AlertDialogCancel>
+            <AlertDialogAction onClick={handleConfirmBulkDelete}>
+              삭제
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </>
+  );
+}
diff --git a/src/components/atoms/BadgeSm.tsx b/src/components/atoms/BadgeSm.tsx
new file mode 100644
index 00000000..1f6c304e
--- /dev/null
+++ b/src/components/atoms/BadgeSm.tsx
@@ -0,0 +1,117 @@
+"use client";
+
+import { ReactNode } from "react";
+import { cn } from "@/lib/utils";
+
+/**
+ * BadgeSm - 작은 크기의 상태 뱃지 컴포넌트
+ *
+ * 견적 관리 시스템의 상태를 표시하는 데 사용되는 작은 뱃지입니다.
+ *
+ * @example
+ * // 수주전환 상태
+ * <BadgeSm variant="converted">수주전환</BadgeSm>
+ *
+ * // 최종확정 상태
+ * <BadgeSm variant="finalized">최종확정</BadgeSm>
+ *
+ * // 수정중 상태
+ * <BadgeSm variant="revising">2차 수정</BadgeSm>
+ *
+ * // 최초작성 상태
+ * <BadgeSm variant="initial">최초 작성</BadgeSm>
+ */
+
+export type BadgeSmVariant =
+  | "converted"    // 수주전환 - 보라색
+  | "finalized"    // 최종확정 - 초록색
+  | "revising"     // 수정중 - 주황색
+  | "initial"      // 최초작성 - 회색
+  | "current"      // 현재버전 - 파란색
+  | "default"      // 기본 - 회색
+  | "outline";     // 외곽선 - 회색 테두리
+
+interface BadgeSmProps {
+  variant?: BadgeSmVariant;
+  children: ReactNode;
+  className?: string;
+}
+
+const variantStyles: Record<BadgeSmVariant, string> = {
+  converted: "bg-purple-600 text-white border-purple-600",
+  finalized: "bg-green-600 text-white border-green-600",
+  revising: "bg-orange-100 text-orange-700 border-orange-300",
+  initial: "bg-gray-50 text-gray-700 border-gray-200",
+  current: "bg-blue-600 text-white border-blue-600",
+  default: "bg-gray-100 text-gray-700 border-gray-200",
+  outline: "bg-transparent text-gray-700 border-gray-300",
+};
+
+export function BadgeSm({
+  variant = "default",
+  children,
+  className
+}: BadgeSmProps) {
+  return (
+    <span
+      className={cn(
+        // 기본 스타일
+        "inline-flex items-center justify-center",
+        "px-2.5 py-0.5",
+        "text-xs font-medium",
+        "rounded-md",
+        "border",
+        "transition-colors",
+        // variant별 스타일
+        variantStyles[variant],
+        // 커스텀 클래스
+        className
+      )}
+    >
+      {children}
+    </span>
+  );
+}
+
+/**
+ * 견적 상태에 따라 적절한 BadgeSm을 반환하는 헬퍼 함수
+ */
+export function getQuoteStatusBadge(quote: {
+  status?: string;
+  isFinal?: boolean;
+  currentRevision?: number;
+}) {
+  // 수주전환
+  if (quote.status === "converted") {
+    return (
+      <BadgeSm variant="converted">
+        수주전환
+      </BadgeSm>
+    );
+  }
+
+  // 최종확정
+  if (quote.isFinal) {
+    return (
+      <BadgeSm variant="finalized">
+        최종확정
+      </BadgeSm>
+    );
+  }
+
+  // 수정중
+  if (quote.currentRevision && quote.currentRevision > 0) {
+    return (
+      <BadgeSm variant="revising">
+        {quote.currentRevision}차 수정
+      </BadgeSm>
+    );
+  }
+
+  // 최초작성
+  return (
+    <BadgeSm variant="initial">
+      최초 작성
+    </BadgeSm>
+  );
+}
\ No newline at end of file
diff --git a/src/components/atoms/TabChip.tsx b/src/components/atoms/TabChip.tsx
new file mode 100644
index 00000000..9e8dcf7a
--- /dev/null
+++ b/src/components/atoms/TabChip.tsx
@@ -0,0 +1,66 @@
+"use client";
+
+/**
+ * TabChip - 모바일용 탭 칩 컴포넌트
+ *
+ * 디자인시스템 Atoms로 등록된 재사용 가능한 탭 칩입니다.
+ * - 활성/비활성 상태 스타일
+ * - 카운트 표시
+ * - 색상 변형 지원
+ */
+
+export interface TabChipProps {
+  /** 탭 라벨 */
+  label: string;
+  /** 카운트 숫자 */
+  count?: number;
+  /** 활성 상태 */
+  active?: boolean;
+  /** 클릭 이벤트 */
+  onClick?: () => void;
+  /** 색상 테마 */
+  color?: "blue" | "gray" | "green" | "orange" | "purple" | "red";
+  /** 추가 className */
+  className?: string;
+}
+
+export function TabChip({
+  label,
+  count,
+  active = false,
+  onClick,
+  color = "blue",
+  className = "",
+}: TabChipProps) {
+  return (
+    <button
+      onClick={onClick}
+      className={`
+        flex items-center gap-2 px-4 py-2.5 rounded-full border transition-all
+        ${
+          active
+            ? "border-primary bg-primary/5"
+            : "border-gray-200 hover:border-gray-300 hover:bg-gray-50"
+        }
+        ${className}
+      `}
+    >
+      <span
+        className={`text-sm ${
+          active ? "text-primary font-medium" : "text-gray-600 font-normal"
+        }`}
+      >
+        {label}
+      </span>
+      {count !== undefined && (
+        <span
+          className={`text-sm font-semibold ${
+            active ? "text-primary" : "text-gray-900"
+          }`}
+        >
+          {count}
+        </span>
+      )}
+    </button>
+  );
+}
\ No newline at end of file
diff --git a/src/components/atoms/index.ts b/src/components/atoms/index.ts
new file mode 100644
index 00000000..180124c3
--- /dev/null
+++ b/src/components/atoms/index.ts
@@ -0,0 +1,5 @@
+export { BadgeSm, getQuoteStatusBadge } from "./BadgeSm";
+export type { BadgeSmVariant } from "./BadgeSm";
+
+export { TabChip } from "./TabChip";
+export type { TabChipProps } from "./TabChip";
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/DynamicField.tsx b/src/components/items/DynamicItemForm/DynamicField.tsx
deleted file mode 100644
index e8eca7f5..00000000
--- a/src/components/items/DynamicItemForm/DynamicField.tsx
+++ /dev/null
@@ -1,63 +0,0 @@
-/**
- * DynamicField Component
- *
- * 필드 타입에 따라 적절한 필드 컴포넌트를 렌더링
- */
-
-'use client';
-
-import type { DynamicFieldProps, FieldType } from './types';
-import {
-  TextField,
-  DropdownField,
-  NumberField,
-  DateField,
-  CheckboxField,
-  FileField,
-  CustomField,
-} from './fields';
-
-/**
- * 필드 타입 → 컴포넌트 매핑
- */
-const FIELD_COMPONENTS: Record<
-  FieldType,
-  React.ComponentType<DynamicFieldProps>
-> = {
-  textbox: TextField,
-  textarea: TextField,
-  dropdown: DropdownField,
-  'searchable-dropdown': DropdownField,
-  number: NumberField,
-  currency: NumberField,
-  date: DateField,
-  'date-range': DateField,
-  checkbox: CheckboxField,
-  switch: CheckboxField,
-  file: FileField,
-  'custom:drawing-canvas': CustomField,
-  'custom:bending-detail-table': CustomField,
-  'custom:bom-table': CustomField,
-};
-
-export function DynamicField(props: DynamicFieldProps) {
-  const { field } = props;
-
-  // 필드 타입에 맞는 컴포넌트 선택
-  const FieldComponent = FIELD_COMPONENTS[field.field_type];
-
-  if (!FieldComponent) {
-    console.warn(`[DynamicField] Unknown field type: ${field.field_type}`);
-    return (
-      <div className="p-4 border border-red-200 bg-red-50 rounded-md">
-        <p className="text-sm text-red-600">
-          알 수 없는 필드 타입: {field.field_type}
-        </p>
-      </div>
-    );
-  }
-
-  return <FieldComponent {...props} />;
-}
-
-export default DynamicField;
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/DynamicFormRenderer.tsx b/src/components/items/DynamicItemForm/DynamicFormRenderer.tsx
deleted file mode 100644
index 758dcc0d..00000000
--- a/src/components/items/DynamicItemForm/DynamicFormRenderer.tsx
+++ /dev/null
@@ -1,75 +0,0 @@
-/**
- * DynamicFormRenderer Component
- *
- * 전체 폼 구조를 렌더링하는 메인 렌더러
- * - 섹션 순서대로 렌더링
- * - 조건부 섹션/필드 처리
- */
-
-'use client';
-
-import { DynamicSection } from './DynamicSection';
-import { useConditionalFields } from './hooks/useConditionalFields';
-import type { DynamicFormRendererProps, DynamicSection as DynamicSectionType } from './types';
-
-export function DynamicFormRenderer({
-  sections,
-  conditionalSections,
-  conditionalFields,
-  values,
-  errors,
-  onChange,
-  onBlur,
-  disabled,
-}: DynamicFormRendererProps) {
-  // 조건부 표시 로직
-  const { isSectionVisible, isFieldVisible } = useConditionalFields({
-    sections,
-    conditionalSections,
-    conditionalFields,
-    values,
-  });
-
-  // 섹션 순서대로 정렬
-  const sortedSections = [...sections].sort((a, b) => a.order_no - b.order_no);
-
-  // 표시할 섹션만 필터링
-  const visibleSections = sortedSections.filter((section) =>
-    isSectionVisible(section.id)
-  );
-
-  // 각 섹션의 표시할 필드만 필터링
-  const sectionsWithVisibleFields: DynamicSectionType[] = visibleSections.map((section) => ({
-    ...section,
-    fields: section.fields.filter((field) =>
-      isFieldVisible(section.id, field.id)
-    ),
-  }));
-
-  if (sectionsWithVisibleFields.length === 0) {
-    return (
-      <div className="p-8 text-center text-gray-500 border-2 border-dashed rounded-lg">
-        <p>표시할 섹션이 없습니다.</p>
-        <p className="text-sm mt-1">품목 유형을 선택하거나 필수 필드를 입력해주세요.</p>
-      </div>
-    );
-  }
-
-  return (
-    <div className="space-y-4">
-      {sectionsWithVisibleFields.map((section) => (
-        <DynamicSection
-          key={section.id}
-          section={section}
-          values={values}
-          errors={errors}
-          onChange={onChange}
-          onBlur={onBlur}
-          disabled={disabled}
-        />
-      ))}
-    </div>
-  );
-}
-
-export default DynamicFormRenderer;
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/DynamicSection.tsx b/src/components/items/DynamicItemForm/DynamicSection.tsx
deleted file mode 100644
index 8ed23c94..00000000
--- a/src/components/items/DynamicItemForm/DynamicSection.tsx
+++ /dev/null
@@ -1,162 +0,0 @@
-/**
- * DynamicSection Component
- *
- * 동적 섹션 렌더링 (Card + 접기/펼치기 + 필드 그리드)
- */
-
-'use client';
-
-import { useState } from 'react';
-import { ChevronDown, ChevronRight } from 'lucide-react';
-import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
-import { Button } from '@/components/ui/button';
-import { DynamicField } from './DynamicField';
-import type { DynamicSectionProps, DynamicField as DynamicFieldType } from './types';
-import { cn } from '@/lib/utils';
-
-/**
- * 필드를 그리드 레이아웃으로 정렬
- */
-function organizeFieldsIntoGrid(fields: DynamicFieldType[]): DynamicFieldType[][] {
-  if (fields.length === 0) return [];
-
-  // 정렬: order_no → grid_row → grid_col
-  const sortedFields = [...fields].sort((a, b) => {
-    if (a.order_no !== b.order_no) return a.order_no - b.order_no;
-    if ((a.grid_row || 1) !== (b.grid_row || 1)) return (a.grid_row || 1) - (b.grid_row || 1);
-    return (a.grid_col || 1) - (b.grid_col || 1);
-  });
-
-  // 행별로 그룹화
-  const rows: Map<number, DynamicFieldType[]> = new Map();
-
-  for (const field of sortedFields) {
-    const row = field.grid_row || 1;
-    if (!rows.has(row)) {
-      rows.set(row, []);
-    }
-    rows.get(row)!.push(field);
-  }
-
-  // 배열로 변환 (행 번호 순서대로)
-  return Array.from(rows.entries())
-    .sort(([a], [b]) => a - b)
-    .map(([, fields]) => fields);
-}
-
-/**
- * grid_span을 Tailwind 클래스로 변환
- */
-function getGridSpanClass(span: number = 1): string {
-  const spanClasses: Record<number, string> = {
-    1: 'col-span-1',
-    2: 'col-span-2',
-    3: 'col-span-3',
-    4: 'col-span-4',
-  };
-  return spanClasses[span] || 'col-span-1';
-}
-
-export function DynamicSection({
-  section,
-  values,
-  errors,
-  onChange,
-  onBlur,
-  disabled,
-}: DynamicSectionProps) {
-  const [isOpen, setIsOpen] = useState(section.is_default_open);
-
-  // BOM 섹션은 별도 처리
-  const isBomSection = section.section_type === 'BOM';
-
-  // 필드를 그리드로 정렬
-  const fieldRows = organizeFieldsIntoGrid(section.fields);
-
-  const handleToggle = () => {
-    if (section.is_collapsible) {
-      setIsOpen(!isOpen);
-    }
-  };
-
-  return (
-    <Card className="mb-4">
-      <CardHeader
-        className={cn(
-          'py-4',
-          section.is_collapsible && 'cursor-pointer hover:bg-gray-50 transition-colors'
-        )}
-        onClick={handleToggle}
-      >
-        <div className="flex items-center justify-between">
-          <CardTitle className="text-base font-semibold flex items-center gap-2">
-            {section.is_collapsible && (
-              <span className="text-gray-400">
-                {isOpen ? (
-                  <ChevronDown className="h-5 w-5" />
-                ) : (
-                  <ChevronRight className="h-5 w-5" />
-                )}
-              </span>
-            )}
-            {section.title}
-          </CardTitle>
-
-          {section.description && (
-            <p className="text-sm text-muted-foreground">{section.description}</p>
-          )}
-        </div>
-      </CardHeader>
-
-      {(isOpen || !section.is_collapsible) && (
-        <CardContent className="pt-0">
-          {isBomSection ? (
-            // BOM 섹션: 별도 컴포넌트로 처리
-            <div className="p-4 border-2 border-dashed border-gray-300 rounded-lg text-center bg-gray-50">
-              <p className="text-gray-500 font-medium">부품 구성 (BOM)</p>
-              <p className="text-sm text-gray-400 mt-1">
-                기존 BOMSection 컴포넌트 통합 예정
-              </p>
-            </div>
-          ) : (
-            // 일반 섹션: 필드 그리드 렌더링
-            <div className="space-y-4">
-              {fieldRows.map((rowFields, rowIndex) => (
-                <div
-                  key={`row-${rowIndex}`}
-                  className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4"
-                >
-                  {rowFields.map((field) => (
-                    <div
-                      key={field.id}
-                      className={cn(
-                        getGridSpanClass(field.grid_span),
-                        // 모바일에서는 항상 전체 너비
-                        'col-span-1 md:col-span-1',
-                        // md 이상에서 grid_span 적용
-                        field.grid_span && field.grid_span >= 2 && 'md:col-span-2',
-                        field.grid_span && field.grid_span >= 3 && 'lg:col-span-3',
-                        field.grid_span && field.grid_span >= 4 && 'lg:col-span-4'
-                      )}
-                    >
-                      <DynamicField
-                        field={field}
-                        value={values[field.field_key]}
-                        error={errors[field.field_key]}
-                        onChange={(value) => onChange(field.field_key, value)}
-                        onBlur={() => onBlur(field.field_key)}
-                        disabled={disabled}
-                      />
-                    </div>
-                  ))}
-                </div>
-              ))}
-            </div>
-          )}
-        </CardContent>
-      )}
-    </Card>
-  );
-}
-
-export default DynamicSection;
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/fields/CheckboxField.tsx b/src/components/items/DynamicItemForm/fields/CheckboxField.tsx
index ba4edf3a..ca940984 100644
--- a/src/components/items/DynamicItemForm/fields/CheckboxField.tsx
+++ b/src/components/items/DynamicItemForm/fields/CheckboxField.tsx
@@ -1,91 +1,46 @@
 /**
- * CheckboxField Component
- *
- * 체크박스/스위치 필드 (checkbox, switch)
+ * 체크박스 필드 컴포넌트
+ * 기존 ItemForm과 100% 동일한 디자인
  */
 
 'use client';
 
-import { Checkbox } from '@/components/ui/checkbox';
-import { Switch } from '@/components/ui/switch';
 import { Label } from '@/components/ui/label';
-import type { DynamicFieldProps } from '../types';
-import { cn } from '@/lib/utils';
+import { Checkbox } from '@/components/ui/checkbox';
+import type { DynamicFieldRendererProps } from '../types';
 
 export function CheckboxField({
   field,
   value,
-  error,
   onChange,
-  onBlur,
+  error,
   disabled,
-}: DynamicFieldProps) {
-  const isSwitch = field.field_type === 'switch';
-  const checked = value === true || value === 'true' || value === 1;
-
-  const handleChange = (newChecked: boolean) => {
-    onChange(newChecked);
-    onBlur();
-  };
-
-  if (isSwitch) {
-    return (
-      <div className="space-y-2">
-        <div className="flex items-center justify-between">
-          <Label
-            htmlFor={field.field_key}
-            className={cn(
-              'text-sm font-medium',
-              field.is_required && "after:content-['*'] after:ml-0.5 after:text-red-500"
-            )}
-          >
-            {field.field_name}
-          </Label>
-          <Switch
-            id={field.field_key}
-            checked={checked}
-            onCheckedChange={handleChange}
-            disabled={disabled || field.is_readonly}
-          />
-        </div>
-
-        {field.help_text && !error && (
-          <p className="text-xs text-muted-foreground">{field.help_text}</p>
-        )}
-
-        {error && <p className="text-xs text-red-500">{error}</p>}
-      </div>
-    );
-  }
+}: DynamicFieldRendererProps) {
+  const fieldKey = field.field_key || `field_${field.id}`;
+  const boolValue = value === true || value === 'true' || value === 1;
 
   return (
-    <div className="space-y-2">
+    <div>
       <div className="flex items-center space-x-2">
         <Checkbox
-          id={field.field_key}
-          checked={checked}
-          onCheckedChange={handleChange}
-          disabled={disabled || field.is_readonly}
+          id={fieldKey}
+          checked={boolValue}
+          onCheckedChange={(checked) => onChange(checked as boolean)}
+          disabled={disabled}
         />
-        <Label
-          htmlFor={field.field_key}
-          className={cn(
-            'text-sm font-medium cursor-pointer',
-            field.is_required && "after:content-['*'] after:ml-0.5 after:text-red-500",
-            (disabled || field.is_readonly) && 'cursor-not-allowed opacity-50'
-          )}
-        >
+        <Label htmlFor={fieldKey} className="cursor-pointer">
           {field.field_name}
+          {field.is_required && <span className="text-red-500"> *</span>}
         </Label>
       </div>
-
-      {field.help_text && !error && (
-        <p className="text-xs text-muted-foreground ml-6">{field.help_text}</p>
+      {error && (
+        <p className="text-xs text-red-500 mt-1 ml-6">{error}</p>
+      )}
+      {!error && field.description && (
+        <p className="text-xs text-muted-foreground mt-1 ml-6">
+          * {field.description}
+        </p>
       )}
-
-      {error && <p className="text-xs text-red-500 ml-6">{error}</p>}
     </div>
   );
 }
-
-export default CheckboxField;
diff --git a/src/components/items/DynamicItemForm/fields/CustomField.tsx b/src/components/items/DynamicItemForm/fields/CustomField.tsx
deleted file mode 100644
index dcadd75e..00000000
--- a/src/components/items/DynamicItemForm/fields/CustomField.tsx
+++ /dev/null
@@ -1,479 +0,0 @@
-/**
- * CustomField Component
- *
- * 특수 필드 컴포넌트 래퍼 (전개도, BOM 등)
- * - custom:drawing-canvas → DrawingCanvas
- * - custom:bending-detail-table → BendingDetailTable (전개도 상세 테이블)
- * - custom:bom-table → BOMSection
- *
- * 기존 ItemForm의 특수 컴포넌트를 재사용하면서 동적 폼과 통합
- */
-
-'use client';
-
-import { useState, useCallback } from 'react';
-import { Label } from '@/components/ui/label';
-import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
-import { Button } from '@/components/ui/button';
-import { Input } from '@/components/ui/input';
-import { FileImage, Plus, Trash2 } from 'lucide-react';
-import type { DynamicFieldProps, FormValue } from '../types';
-import type { BendingDetail, BOMLine } from '@/types/item';
-import { cn } from '@/lib/utils';
-
-// ===== BOM 테이블 컴포넌트 =====
-
-interface BOMTableProps {
-  value: BOMLine[];
-  onChange: (lines: BOMLine[]) => void;
-  disabled?: boolean;
-}
-
-function BOMTable({ value, onChange, disabled }: BOMTableProps) {
-  const bomLines = Array.isArray(value) ? value : [];
-
-  const addLine = () => {
-    const newLine: BOMLine = {
-      id: `bom-${Date.now()}`,
-      childItemCode: '',
-      childItemName: '',
-      quantity: 1,
-      unit: 'EA',
-    };
-    onChange([...bomLines, newLine]);
-  };
-
-  const updateLine = (index: number, field: keyof BOMLine, fieldValue: string | number) => {
-    const updated = [...bomLines];
-    updated[index] = { ...updated[index], [field]: fieldValue };
-    onChange(updated);
-  };
-
-  const removeLine = (index: number) => {
-    onChange(bomLines.filter((_, i) => i !== index));
-  };
-
-  return (
-    <Card>
-      <CardHeader className="py-3">
-        <div className="flex items-center justify-between">
-          <CardTitle className="text-sm">부품 구성 (BOM)</CardTitle>
-          <Button
-            type="button"
-            variant="outline"
-            size="sm"
-            onClick={addLine}
-            disabled={disabled}
-          >
-            <Plus className="h-4 w-4 mr-1" />
-            추가
-          </Button>
-        </div>
-      </CardHeader>
-      <CardContent className="pt-0">
-        {bomLines.length === 0 ? (
-          <div className="text-center py-8 text-muted-foreground border-2 border-dashed rounded-lg">
-            <p>등록된 BOM 항목이 없습니다.</p>
-            <p className="text-sm mt-1">위 버튼을 클릭하여 품목을 추가하세요.</p>
-          </div>
-        ) : (
-          <div className="space-y-2">
-            <div className="grid grid-cols-12 gap-2 text-xs font-medium text-muted-foreground px-2">
-              <div className="col-span-3">품목코드</div>
-              <div className="col-span-4">품목명</div>
-              <div className="col-span-2">수량</div>
-              <div className="col-span-2">단위</div>
-              <div className="col-span-1"></div>
-            </div>
-            {bomLines.map((line, index) => (
-              <div key={line.id} className="grid grid-cols-12 gap-2 items-center">
-                <Input
-                  className="col-span-3 h-8 text-sm"
-                  placeholder="품목코드"
-                  value={line.childItemCode}
-                  onChange={(e) => updateLine(index, 'childItemCode', e.target.value)}
-                  disabled={disabled}
-                />
-                <Input
-                  className="col-span-4 h-8 text-sm"
-                  placeholder="품목명"
-                  value={line.childItemName}
-                  onChange={(e) => updateLine(index, 'childItemName', e.target.value)}
-                  disabled={disabled}
-                />
-                <Input
-                  className="col-span-2 h-8 text-sm text-right"
-                  type="number"
-                  min={1}
-                  value={line.quantity}
-                  onChange={(e) => updateLine(index, 'quantity', parseInt(e.target.value) || 1)}
-                  disabled={disabled}
-                />
-                <Input
-                  className="col-span-2 h-8 text-sm"
-                  value={line.unit}
-                  onChange={(e) => updateLine(index, 'unit', e.target.value)}
-                  disabled={disabled}
-                />
-                <Button
-                  type="button"
-                  variant="ghost"
-                  size="sm"
-                  className="col-span-1 h-8 w-8 p-0"
-                  onClick={() => removeLine(index)}
-                  disabled={disabled}
-                >
-                  <Trash2 className="h-4 w-4 text-red-500" />
-                </Button>
-              </div>
-            ))}
-          </div>
-        )}
-      </CardContent>
-    </Card>
-  );
-}
-
-// ===== 전개도 상세 테이블 컴포넌트 =====
-
-interface BendingDetailTableProps {
-  value: BendingDetail[];
-  onChange: (details: BendingDetail[]) => void;
-  disabled?: boolean;
-}
-
-function BendingDetailTable({ value, onChange, disabled }: BendingDetailTableProps) {
-  const details = Array.isArray(value) ? value : [];
-
-  // 폭 합계 계산
-  const totalWidth = details.reduce((acc, d) => acc + d.input + d.elongation, 0);
-
-  const addRow = () => {
-    const newRow: BendingDetail = {
-      id: `bend-${Date.now()}`,
-      no: details.length + 1,
-      input: 0,
-      elongation: -1,
-      calculated: 0,
-      sum: 0,
-      shaded: false,
-    };
-    onChange([...details, newRow]);
-  };
-
-  const updateRow = (index: number, field: keyof BendingDetail, fieldValue: number | boolean) => {
-    const updated = [...details];
-    updated[index] = { ...updated[index], [field]: fieldValue };
-
-    // calculated와 sum 자동 계산
-    if (field === 'input' || field === 'elongation') {
-      const input = field === 'input' ? (fieldValue as number) : updated[index].input;
-      const elongation = field === 'elongation' ? (fieldValue as number) : updated[index].elongation;
-      updated[index].calculated = input + elongation;
-
-      // 누적 합계 재계산
-      let runningSum = 0;
-      for (let i = 0; i <= index; i++) {
-        runningSum += updated[i].input + updated[i].elongation;
-        updated[i].sum = runningSum;
-      }
-    }
-
-    onChange(updated);
-  };
-
-  const removeRow = (index: number) => {
-    const updated = details.filter((_, i) => i !== index);
-    // 번호 재정렬
-    updated.forEach((row, i) => {
-      row.no = i + 1;
-    });
-    onChange(updated);
-  };
-
-  return (
-    <Card>
-      <CardHeader className="py-3">
-        <div className="flex items-center justify-between">
-          <CardTitle className="text-sm flex items-center gap-2">
-            <FileImage className="h-4 w-4" />
-            전개도 상세 입력
-          </CardTitle>
-          <div className="flex items-center gap-3">
-            <span className="text-sm text-muted-foreground">
-              폭 합계: <strong className="text-foreground">{totalWidth.toFixed(1)} mm</strong>
-            </span>
-            <Button
-              type="button"
-              variant="outline"
-              size="sm"
-              onClick={addRow}
-              disabled={disabled}
-            >
-              <Plus className="h-4 w-4 mr-1" />
-              행 추가
-            </Button>
-          </div>
-        </div>
-      </CardHeader>
-      <CardContent className="pt-0">
-        {details.length === 0 ? (
-          <div className="text-center py-8 text-muted-foreground border-2 border-dashed rounded-lg">
-            <p>전개도 상세 데이터가 없습니다.</p>
-            <p className="text-sm mt-1">위 버튼을 클릭하여 행을 추가하세요.</p>
-          </div>
-        ) : (
-          <div className="space-y-2">
-            <div className="grid grid-cols-12 gap-2 text-xs font-medium text-muted-foreground px-2">
-              <div className="col-span-1">No</div>
-              <div className="col-span-2">입력값</div>
-              <div className="col-span-2">연신율</div>
-              <div className="col-span-2">계산값</div>
-              <div className="col-span-2">합계</div>
-              <div className="col-span-2">음영</div>
-              <div className="col-span-1"></div>
-            </div>
-            {details.map((row, index) => (
-              <div key={row.id} className="grid grid-cols-12 gap-2 items-center">
-                <div className="col-span-1 text-sm text-center text-muted-foreground">
-                  {row.no}
-                </div>
-                <Input
-                  className="col-span-2 h-8 text-sm text-right"
-                  type="number"
-                  step="0.1"
-                  value={row.input}
-                  onChange={(e) => updateRow(index, 'input', parseFloat(e.target.value) || 0)}
-                  disabled={disabled}
-                />
-                <Input
-                  className="col-span-2 h-8 text-sm text-right"
-                  type="number"
-                  step="0.1"
-                  value={row.elongation}
-                  onChange={(e) => updateRow(index, 'elongation', parseFloat(e.target.value) || 0)}
-                  disabled={disabled}
-                />
-                <div className="col-span-2 text-sm text-right pr-3 text-muted-foreground">
-                  {(row.input + row.elongation).toFixed(1)}
-                </div>
-                <div className="col-span-2 text-sm text-right pr-3 font-medium">
-                  {row.sum.toFixed(1)}
-                </div>
-                <div className="col-span-2 flex justify-center">
-                  <input
-                    type="checkbox"
-                    checked={row.shaded}
-                    onChange={(e) => updateRow(index, 'shaded', e.target.checked)}
-                    disabled={disabled}
-                    className="h-4 w-4"
-                  />
-                </div>
-                <Button
-                  type="button"
-                  variant="ghost"
-                  size="sm"
-                  className="col-span-1 h-8 w-8 p-0"
-                  onClick={() => removeRow(index)}
-                  disabled={disabled}
-                >
-                  <Trash2 className="h-4 w-4 text-red-500" />
-                </Button>
-              </div>
-            ))}
-          </div>
-        )}
-      </CardContent>
-    </Card>
-  );
-}
-
-// ===== 전개도 캔버스 (간단 버전) =====
-
-interface DrawingCanvasProps {
-  value: string | null;
-  onChange: (dataUrl: string | null) => void;
-  disabled?: boolean;
-}
-
-function DrawingCanvasSimple({ value, onChange, disabled }: DrawingCanvasProps) {
-  const [inputMethod, setInputMethod] = useState<'file' | 'drawing'>('file');
-
-  const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
-    const file = e.target.files?.[0];
-    if (!file) return;
-
-    const reader = new FileReader();
-    reader.onload = (event) => {
-      onChange(event.target?.result as string);
-    };
-    reader.readAsDataURL(file);
-  };
-
-  const handleClear = () => {
-    onChange(null);
-  };
-
-  return (
-    <Card>
-      <CardHeader className="py-3">
-        <CardTitle className="text-sm flex items-center gap-2">
-          <FileImage className="h-4 w-4" />
-          전개도 이미지
-        </CardTitle>
-      </CardHeader>
-      <CardContent className="space-y-4">
-        {/* 입력 방식 선택 */}
-        <div className="flex gap-4">
-          <label className="flex items-center gap-2 cursor-pointer">
-            <input
-              type="radio"
-              name="drawingMethod"
-              checked={inputMethod === 'file'}
-              onChange={() => setInputMethod('file')}
-              disabled={disabled}
-            />
-            <span className="text-sm">파일 업로드</span>
-          </label>
-          <label className="flex items-center gap-2 cursor-pointer">
-            <input
-              type="radio"
-              name="drawingMethod"
-              checked={inputMethod === 'drawing'}
-              onChange={() => setInputMethod('drawing')}
-              disabled={disabled}
-            />
-            <span className="text-sm">직접 그리기 (준비 중)</span>
-          </label>
-        </div>
-
-        {/* 파일 업로드 */}
-        {inputMethod === 'file' && (
-          <div>
-            {value ? (
-              <div className="relative">
-                <img
-                  src={value}
-                  alt="전개도"
-                  className="max-w-full h-auto border rounded-lg"
-                />
-                <Button
-                  type="button"
-                  variant="destructive"
-                  size="sm"
-                  className="absolute top-2 right-2"
-                  onClick={handleClear}
-                  disabled={disabled}
-                >
-                  <Trash2 className="h-4 w-4" />
-                </Button>
-              </div>
-            ) : (
-              <div className="border-2 border-dashed rounded-lg p-8 text-center">
-                <input
-                  type="file"
-                  accept="image/*"
-                  onChange={handleFileChange}
-                  disabled={disabled}
-                  className="hidden"
-                  id="drawing-file-input"
-                />
-                <label
-                  htmlFor="drawing-file-input"
-                  className="cursor-pointer text-muted-foreground hover:text-foreground"
-                >
-                  <FileImage className="h-12 w-12 mx-auto mb-2 opacity-50" />
-                  <p>클릭하여 이미지를 업로드하세요</p>
-                  <p className="text-xs mt-1">PNG, JPG, GIF 지원</p>
-                </label>
-              </div>
-            )}
-          </div>
-        )}
-
-        {/* 직접 그리기 (플레이스홀더) */}
-        {inputMethod === 'drawing' && (
-          <div className="border-2 border-dashed rounded-lg p-8 text-center text-muted-foreground">
-            <p>직접 그리기 기능은 준비 중입니다.</p>
-            <p className="text-sm mt-1">기존 DrawingCanvas 컴포넌트와 통합 예정</p>
-          </div>
-        )}
-      </CardContent>
-    </Card>
-  );
-}
-
-// ===== 메인 CustomField 컴포넌트 =====
-
-export function CustomField({
-  field,
-  value,
-  error,
-  onChange,
-  onBlur,
-  disabled,
-}: DynamicFieldProps) {
-  const renderCustomComponent = () => {
-    switch (field.field_type) {
-      case 'custom:drawing-canvas':
-        return (
-          <DrawingCanvasSimple
-            value={value as string | null}
-            onChange={(dataUrl) => {
-              onChange(dataUrl);
-              onBlur();
-            }}
-            disabled={disabled}
-          />
-        );
-
-      case 'custom:bending-detail-table':
-        return (
-          <BendingDetailTable
-            value={value as BendingDetail[] || []}
-            onChange={(details) => {
-              onChange(details as unknown as FormValue);
-              onBlur();
-            }}
-            disabled={disabled}
-          />
-        );
-
-      case 'custom:bom-table':
-        return (
-          <BOMTable
-            value={value as BOMLine[] || []}
-            onChange={(lines) => {
-              onChange(lines as unknown as FormValue);
-              onBlur();
-            }}
-            disabled={disabled}
-          />
-        );
-
-      default:
-        return (
-          <div className="p-4 border border-orange-200 bg-orange-50 rounded-md">
-            <p className="text-sm text-orange-600">
-              알 수 없는 커스텀 필드 타입: {field.field_type}
-            </p>
-          </div>
-        );
-    }
-  };
-
-  // 커스텀 필드는 자체 레이블이 있으므로 별도 레이블 불필요
-  return (
-    <div className="space-y-2">
-      {renderCustomComponent()}
-
-      {field.help_text && !error && (
-        <p className="text-xs text-muted-foreground">{field.help_text}</p>
-      )}
-
-      {error && <p className="text-xs text-red-500">{error}</p>}
-    </div>
-  );
-}
-
-export default CustomField;
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/fields/DateField.tsx b/src/components/items/DynamicItemForm/fields/DateField.tsx
index 27b69515..130e4cb7 100644
--- a/src/components/items/DynamicItemForm/fields/DateField.tsx
+++ b/src/components/items/DynamicItemForm/fields/DateField.tsx
@@ -1,100 +1,46 @@
 /**
- * DateField Component
- *
- * 날짜 선택 필드 (date, date-range)
+ * 날짜 입력 필드 컴포넌트
+ * 기존 ItemForm과 100% 동일한 디자인
  */
 
 'use client';
 
-import { useState } from 'react';
-import { format } from 'date-fns';
-import { ko } from 'date-fns/locale';
-import { CalendarIcon } from 'lucide-react';
-import { Button } from '@/components/ui/button';
-import { Calendar } from '@/components/ui/calendar';
 import { Label } from '@/components/ui/label';
-import {
-  Popover,
-  PopoverContent,
-  PopoverTrigger,
-} from '@/components/ui/popover';
-import type { DynamicFieldProps } from '../types';
-import { cn } from '@/lib/utils';
+import { Input } from '@/components/ui/input';
+import type { DynamicFieldRendererProps } from '../types';
 
 export function DateField({
   field,
   value,
-  error,
   onChange,
-  onBlur,
+  error,
   disabled,
-}: DynamicFieldProps) {
-  const [open, setOpen] = useState(false);
-
-  // 값을 Date 객체로 변환
-  const dateValue = value ? new Date(value as string) : undefined;
-  const isValidDate = dateValue && !isNaN(dateValue.getTime());
-
-  const handleSelect = (date: Date | undefined) => {
-    if (date) {
-      // ISO 문자열로 변환 (YYYY-MM-DD)
-      onChange(format(date, 'yyyy-MM-dd'));
-    } else {
-      onChange(null);
-    }
-    setOpen(false);
-    onBlur();
-  };
+}: DynamicFieldRendererProps) {
+  const fieldKey = field.field_key || `field_${field.id}`;
+  const stringValue = value !== null && value !== undefined ? String(value) : '';
 
   return (
-    <div className="space-y-2">
-      <Label
-        htmlFor={field.field_key}
-        className={cn(
-          'text-sm font-medium',
-          field.is_required && "after:content-['*'] after:ml-0.5 after:text-red-500"
-        )}
-      >
+    <div>
+      <Label htmlFor={fieldKey}>
         {field.field_name}
+        {field.is_required && <span className="text-red-500"> *</span>}
       </Label>
-
-      <Popover open={open} onOpenChange={setOpen}>
-        <PopoverTrigger asChild>
-          <Button
-            id={field.field_key}
-            variant="outline"
-            disabled={disabled || field.is_readonly}
-            className={cn(
-              'w-full justify-start text-left font-normal',
-              !isValidDate && 'text-muted-foreground',
-              error && 'border-red-500 focus:ring-red-500',
-              field.is_readonly && 'bg-gray-50 text-gray-500'
-            )}
-          >
-            <CalendarIcon className="mr-2 h-4 w-4" />
-            {isValidDate
-              ? format(dateValue, 'yyyy년 MM월 dd일', { locale: ko })
-              : field.placeholder || '날짜를 선택하세요'}
-          </Button>
-        </PopoverTrigger>
-        <PopoverContent className="w-auto p-0" align="start">
-          <Calendar
-            mode="single"
-            selected={isValidDate ? dateValue : undefined}
-            onSelect={handleSelect}
-            locale={ko}
-            initialFocus
-          />
-        </PopoverContent>
-      </Popover>
-
-      {field.help_text && !error && (
-        <p className="text-xs text-muted-foreground">{field.help_text}</p>
+      <Input
+        id={fieldKey}
+        type="date"
+        value={stringValue}
+        onChange={(e) => onChange(e.target.value)}
+        disabled={disabled}
+        className={error ? 'border-red-500' : ''}
+      />
+      {error && (
+        <p className="text-xs text-red-500 mt-1">{error}</p>
+      )}
+      {!error && field.description && (
+        <p className="text-xs text-muted-foreground mt-1">
+          * {field.description}
+        </p>
       )}
-
-      {error && <p className="text-xs text-red-500">{error}</p>}
     </div>
   );
 }
-
-export default DateField;
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/fields/DropdownField.tsx b/src/components/items/DynamicItemForm/fields/DropdownField.tsx
index 882e2e74..8adbe377 100644
--- a/src/components/items/DynamicItemForm/fields/DropdownField.tsx
+++ b/src/components/items/DynamicItemForm/fields/DropdownField.tsx
@@ -1,12 +1,11 @@
 /**
- * DropdownField Component
- *
- * 드롭다운/선택 필드 (dropdown, searchable-dropdown)
+ * 드롭다운(Select) 필드 컴포넌트
+ * 기존 ItemForm과 100% 동일한 디자인
  */
 
 'use client';
 
-import { useState, useEffect } from 'react';
+import { Label } from '@/components/ui/label';
 import {
   Select,
   SelectContent,
@@ -14,105 +13,110 @@ import {
   SelectTrigger,
   SelectValue,
 } from '@/components/ui/select';
-import { Label } from '@/components/ui/label';
-import type { DynamicFieldProps, DropdownOption } from '../types';
-import { cn } from '@/lib/utils';
+import type { DynamicFieldRendererProps } from '../types';
+
+// 옵션을 {label, value} 형태로 정규화
+function normalizeOptions(rawOptions: unknown): Array<{ label: string; value: string }> {
+  if (!rawOptions) return [];
+
+  // 문자열인 경우: 콤마로 분리
+  if (typeof rawOptions === 'string') {
+    return rawOptions.split(',').map(o => {
+      const trimmed = o.trim();
+      return { label: trimmed, value: trimmed };
+    });
+  }
+
+  // 배열인 경우
+  if (Array.isArray(rawOptions)) {
+    return rawOptions.map(item => {
+      // 이미 {label, value} 형태
+      if (typeof item === 'object' && item !== null && 'value' in item) {
+        return {
+          label: String(item.label || item.value),
+          value: String(item.value),
+        };
+      }
+      // 문자열 배열
+      const str = String(item);
+      return { label: str, value: str };
+    });
+  }
+
+  return [];
+}
 
 export function DropdownField({
   field,
   value,
-  error,
   onChange,
-  onBlur,
+  error,
   disabled,
-}: DynamicFieldProps) {
-  const [options, setOptions] = useState<DropdownOption[]>(
-    field.dropdown_config?.options || []
-  );
-  const [isLoading, setIsLoading] = useState(false);
+  unitOptions,
+}: DynamicFieldRendererProps) {
+  const fieldKey = field.field_key || `field_${field.id}`;
+  const stringValue = value !== null && value !== undefined ? String(value) : '';
 
-  // API에서 옵션 로드 (options_endpoint가 있는 경우)
-  useEffect(() => {
-    if (field.dropdown_config?.options_endpoint) {
-      setIsLoading(true);
-      fetch(field.dropdown_config.options_endpoint)
-        .then((res) => res.json())
-        .then((data) => {
-          if (data.success && Array.isArray(data.data)) {
-            setOptions(data.data);
-          }
-        })
-        .catch((err) => {
-          console.error('[DropdownField] Failed to load options:', err);
-        })
-        .finally(() => {
-          setIsLoading(false);
-        });
-    }
-  }, [field.dropdown_config?.options_endpoint]);
+  // field_key 또는 field_name이 '단위'/'unit' 관련이면 unitOptions 사용
+  const isUnitField =
+    fieldKey.toLowerCase().includes('unit') ||
+    fieldKey.includes('단위') ||
+    field.field_name.includes('단위') ||
+    field.field_name.toLowerCase().includes('unit');
 
-  const displayValue = value === null || value === undefined ? '' : String(value);
+  // 옵션 목록 결정
+  let options: Array<{ label: string; value: string }> = [];
 
-  const handleValueChange = (newValue: string) => {
-    onChange(newValue);
-    onBlur();
-  };
+  if (isUnitField && unitOptions && unitOptions.length > 0) {
+    options = unitOptions.map((u) => ({
+      label: `${u.label} (${u.value})`,
+      value: u.value,
+    }));
+  } else {
+    // field.options를 정규화
+    options = normalizeOptions(field.options);
+  }
+
+  // 옵션이 없으면 드롭다운을 disabled로 표시
+  const hasOptions = options.length > 0;
 
   return (
-    <div className="space-y-2">
-      <Label
-        htmlFor={field.field_key}
-        className={cn(
-          'text-sm font-medium',
-          field.is_required && "after:content-['*'] after:ml-0.5 after:text-red-500"
-        )}
-      >
+    <div>
+      <Label htmlFor={fieldKey}>
         {field.field_name}
+        {field.is_required && <span className="text-red-500"> *</span>}
       </Label>
-
       <Select
-        value={displayValue}
-        onValueChange={handleValueChange}
-        disabled={disabled || field.is_readonly || isLoading}
+        value={stringValue}
+        onValueChange={onChange}
+        disabled={disabled || !hasOptions}
       >
         <SelectTrigger
-          id={field.field_key}
-          className={cn(
-            error && 'border-red-500 focus:ring-red-500',
-            field.is_readonly && 'bg-gray-50 text-gray-500'
-          )}
+          id={fieldKey}
+          className={error ? 'border-red-500' : ''}
         >
-          <SelectValue
-            placeholder={
-              isLoading
-                ? '로딩 중...'
-                : field.dropdown_config?.placeholder || '선택하세요'
-            }
-          />
+          <SelectValue placeholder={
+            hasOptions
+              ? (field.placeholder || `${field.field_name}을(를) 선택하세요`)
+              : '옵션이 없습니다'
+          } />
         </SelectTrigger>
         <SelectContent>
-          {field.dropdown_config?.allow_empty && (
-            <SelectItem value="">선택 안함</SelectItem>
-          )}
-          {options.map((option) => (
-            <SelectItem
-              key={option.value}
-              value={option.value}
-              disabled={option.disabled}
-            >
+          {options.map((option, index) => (
+            <SelectItem key={`${option.value}-${index}`} value={option.value}>
               {option.label}
             </SelectItem>
           ))}
         </SelectContent>
       </Select>
-
-      {field.help_text && !error && (
-        <p className="text-xs text-muted-foreground">{field.help_text}</p>
+      {error && (
+        <p className="text-xs text-red-500 mt-1">{error}</p>
+      )}
+      {!error && field.description && (
+        <p className="text-xs text-muted-foreground mt-1">
+          * {field.description}
+        </p>
       )}
-
-      {error && <p className="text-xs text-red-500">{error}</p>}
     </div>
   );
 }
-
-export default DropdownField;
diff --git a/src/components/items/DynamicItemForm/fields/DynamicFieldRenderer.tsx b/src/components/items/DynamicItemForm/fields/DynamicFieldRenderer.tsx
new file mode 100644
index 00000000..9974c351
--- /dev/null
+++ b/src/components/items/DynamicItemForm/fields/DynamicFieldRenderer.tsx
@@ -0,0 +1,43 @@
+/**
+ * 동적 필드 렌더러
+ * field_type에 따라 적절한 필드 컴포넌트를 선택하여 렌더링
+ */
+
+'use client';
+
+import { TextField } from './TextField';
+import { NumberField } from './NumberField';
+import { DropdownField } from './DropdownField';
+import { CheckboxField } from './CheckboxField';
+import { DateField } from './DateField';
+import { TextareaField } from './TextareaField';
+import type { DynamicFieldRendererProps } from '../types';
+
+export function DynamicFieldRenderer(props: DynamicFieldRendererProps) {
+  const { field } = props;
+
+  switch (field.field_type) {
+    case 'textbox':
+      return <TextField {...props} />;
+
+    case 'number':
+      return <NumberField {...props} />;
+
+    case 'dropdown':
+      return <DropdownField {...props} />;
+
+    case 'checkbox':
+      return <CheckboxField {...props} />;
+
+    case 'date':
+      return <DateField {...props} />;
+
+    case 'textarea':
+      return <TextareaField {...props} />;
+
+    default:
+      // 알 수 없는 타입은 텍스트 필드로 폴백
+      console.warn(`Unknown field type: ${field.field_type}, falling back to TextField`);
+      return <TextField {...props} />;
+  }
+}
diff --git a/src/components/items/DynamicItemForm/fields/FileField.tsx b/src/components/items/DynamicItemForm/fields/FileField.tsx
deleted file mode 100644
index f26806c2..00000000
--- a/src/components/items/DynamicItemForm/fields/FileField.tsx
+++ /dev/null
@@ -1,203 +0,0 @@
-/**
- * FileField Component
- *
- * 파일 업로드 필드
- */
-
-'use client';
-
-import { useRef, useState } from 'react';
-import { Upload, X, FileText } from 'lucide-react';
-import { Button } from '@/components/ui/button';
-import { Label } from '@/components/ui/label';
-import type { DynamicFieldProps } from '../types';
-import { cn } from '@/lib/utils';
-
-/**
- * 파일 크기 포맷팅
- */
-function formatFileSize(bytes: number): string {
-  if (bytes === 0) return '0 Bytes';
-  const k = 1024;
-  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
-}
-
-export function FileField({
-  field,
-  value,
-  error,
-  onChange,
-  onBlur,
-  disabled,
-}: DynamicFieldProps) {
-  const inputRef = useRef<HTMLInputElement>(null);
-  const [dragOver, setDragOver] = useState(false);
-
-  const fileConfig = field.file_config || {};
-  const accept = fileConfig.accept || '*';
-  const maxSize = fileConfig.max_size || 10 * 1024 * 1024; // 기본 10MB
-  const multiple = fileConfig.multiple || false;
-
-  // 현재 파일(들)
-  const files: File[] = Array.isArray(value)
-    ? value
-    : value instanceof File
-    ? [value]
-    : [];
-
-  const handleFileSelect = (selectedFiles: FileList | null) => {
-    if (!selectedFiles || selectedFiles.length === 0) return;
-
-    const validFiles: File[] = [];
-
-    for (let i = 0; i < selectedFiles.length; i++) {
-      const file = selectedFiles[i];
-
-      // 파일 크기 검사
-      if (file.size > maxSize) {
-        alert(`"${file.name}" 파일이 너무 큽니다. 최대 ${formatFileSize(maxSize)}까지 업로드 가능합니다.`);
-        continue;
-      }
-
-      validFiles.push(file);
-    }
-
-    if (validFiles.length === 0) return;
-
-    if (multiple) {
-      onChange([...files, ...validFiles]);
-    } else {
-      onChange(validFiles[0]);
-    }
-    onBlur();
-  };
-
-  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
-    handleFileSelect(e.target.files);
-    // 같은 파일 재선택 허용을 위해 리셋
-    e.target.value = '';
-  };
-
-  const handleDrop = (e: React.DragEvent) => {
-    e.preventDefault();
-    setDragOver(false);
-    if (disabled || field.is_readonly) return;
-    handleFileSelect(e.dataTransfer.files);
-  };
-
-  const handleDragOver = (e: React.DragEvent) => {
-    e.preventDefault();
-    if (disabled || field.is_readonly) return;
-    setDragOver(true);
-  };
-
-  const handleDragLeave = () => {
-    setDragOver(false);
-  };
-
-  const handleRemoveFile = (index: number) => {
-    if (multiple) {
-      const newFiles = files.filter((_, i) => i !== index);
-      onChange(newFiles.length > 0 ? newFiles : null);
-    } else {
-      onChange(null);
-    }
-    onBlur();
-  };
-
-  const handleClick = () => {
-    if (disabled || field.is_readonly) return;
-    inputRef.current?.click();
-  };
-
-  return (
-    <div className="space-y-2">
-      <Label
-        className={cn(
-          'text-sm font-medium',
-          field.is_required && "after:content-['*'] after:ml-0.5 after:text-red-500"
-        )}
-      >
-        {field.field_name}
-      </Label>
-
-      {/* 드래그 앤 드롭 영역 */}
-      <div
-        onClick={handleClick}
-        onDrop={handleDrop}
-        onDragOver={handleDragOver}
-        onDragLeave={handleDragLeave}
-        className={cn(
-          'border-2 border-dashed rounded-lg p-4 text-center cursor-pointer transition-colors',
-          dragOver && 'border-primary bg-primary/5',
-          error && 'border-red-500',
-          (disabled || field.is_readonly) && 'opacity-50 cursor-not-allowed bg-gray-50',
-          !dragOver && !error && 'border-gray-300 hover:border-gray-400'
-        )}
-      >
-        <input
-          ref={inputRef}
-          type="file"
-          accept={accept}
-          multiple={multiple}
-          onChange={handleInputChange}
-          disabled={disabled || field.is_readonly}
-          className="hidden"
-        />
-
-        <Upload className="mx-auto h-8 w-8 text-gray-400 mb-2" />
-        <p className="text-sm text-gray-600">
-          클릭하거나 파일을 드래그하세요
-        </p>
-        <p className="text-xs text-gray-400 mt-1">
-          {accept !== '*' ? `허용 형식: ${accept}` : '모든 형식 허용'} |
-          최대 {formatFileSize(maxSize)}
-        </p>
-      </div>
-
-      {/* 선택된 파일 목록 */}
-      {files.length > 0 && (
-        <div className="space-y-2">
-          {files.map((file, index) => (
-            <div
-              key={`${file.name}-${index}`}
-              className="flex items-center justify-between p-2 bg-gray-50 rounded-md"
-            >
-              <div className="flex items-center gap-2 min-w-0">
-                <FileText className="h-4 w-4 text-gray-500 flex-shrink-0" />
-                <div className="min-w-0">
-                  <p className="text-sm font-medium truncate">{file.name}</p>
-                  <p className="text-xs text-gray-500">{formatFileSize(file.size)}</p>
-                </div>
-              </div>
-              {!disabled && !field.is_readonly && (
-                <Button
-                  type="button"
-                  variant="ghost"
-                  size="sm"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    handleRemoveFile(index);
-                  }}
-                  className="h-8 w-8 p-0"
-                >
-                  <X className="h-4 w-4" />
-                </Button>
-              )}
-            </div>
-          ))}
-        </div>
-      )}
-
-      {field.help_text && !error && (
-        <p className="text-xs text-muted-foreground">{field.help_text}</p>
-      )}
-
-      {error && <p className="text-xs text-red-500">{error}</p>}
-    </div>
-  );
-}
-
-export default FileField;
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/fields/NumberField.tsx b/src/components/items/DynamicItemForm/fields/NumberField.tsx
index 4b95795c..20ca33a2 100644
--- a/src/components/items/DynamicItemForm/fields/NumberField.tsx
+++ b/src/components/items/DynamicItemForm/fields/NumberField.tsx
@@ -1,122 +1,59 @@
 /**
- * NumberField Component
- *
- * 숫자 입력 필드 (number, currency)
+ * 숫자 입력 필드 컴포넌트
+ * 기존 ItemForm과 100% 동일한 디자인
  */
 
 'use client';
 
-import { useCallback } from 'react';
-import { Input } from '@/components/ui/input';
 import { Label } from '@/components/ui/label';
-import type { DynamicFieldProps } from '../types';
-import { cn } from '@/lib/utils';
-
-/**
- * 숫자 포맷팅 (천단위 콤마)
- */
-function formatNumber(value: number | string, isCurrency: boolean): string {
-  const num = typeof value === 'string' ? parseFloat(value) : value;
-  if (isNaN(num)) return '';
-
-  if (isCurrency) {
-    return num.toLocaleString('ko-KR');
-  }
-  return num.toString();
-}
-
-/**
- * 포맷팅된 문자열을 숫자로 변환
- */
-function parseFormattedNumber(value: string): number {
-  // 콤마 제거 후 숫자로 변환
-  const cleaned = value.replace(/,/g, '');
-  const num = parseFloat(cleaned);
-  return isNaN(num) ? 0 : num;
-}
+import { Input } from '@/components/ui/input';
+import type { DynamicFieldRendererProps } from '../types';
 
 export function NumberField({
   field,
   value,
-  error,
   onChange,
-  onBlur,
+  error,
   disabled,
-}: DynamicFieldProps) {
-  const isCurrency = field.field_type === 'currency';
-  const numValue = typeof value === 'number' ? value : parseFormattedNumber(String(value || '0'));
+}: DynamicFieldRendererProps) {
+  const fieldKey = field.field_key || `field_${field.id}`;
+  const stringValue = value !== null && value !== undefined ? String(value) : '';
 
-  const handleChange = useCallback(
-    (e: React.ChangeEvent<HTMLInputElement>) => {
-      const inputValue = e.target.value;
-
-      // 빈 값 허용
-      if (inputValue === '' || inputValue === '-') {
-        onChange(0);
-        return;
-      }
-
-      // 숫자와 콤마, 소수점, 마이너스만 허용
-      const cleaned = inputValue.replace(/[^\d.,-]/g, '');
-      const num = parseFormattedNumber(cleaned);
-
-      // 유효성 검사
-      const { min, max } = field.validation_rules || {};
-      if (min !== undefined && num < min) return;
-      if (max !== undefined && num > max) return;
-
-      onChange(num);
-    },
-    [onChange, field.validation_rules]
-  );
-
-  // 표시용 값 (통화면 포맷팅)
-  const displayValue = formatNumber(numValue, isCurrency);
+  // properties에서 단위, 정밀도 등 추출
+  const unit = field.properties?.unit as string | undefined;
+  const step = field.properties?.precision ? Math.pow(10, -field.properties.precision) : 1;
 
   return (
-    <div className="space-y-2">
-      <Label
-        htmlFor={field.field_key}
-        className={cn(
-          'text-sm font-medium',
-          field.is_required && "after:content-['*'] after:ml-0.5 after:text-red-500"
-        )}
-      >
+    <div>
+      <Label htmlFor={fieldKey}>
         {field.field_name}
+        {unit && ` (${unit})`}
+        {field.is_required && <span className="text-red-500"> *</span>}
       </Label>
-
-      <div className="relative">
-        {isCurrency && (
-          <span className="absolute left-3 top-1/2 -translate-y-1/2 text-gray-500">
-            ₩
-          </span>
-        )}
-        <Input
-          id={field.field_key}
-          name={field.field_key}
-          type="text"
-          inputMode="numeric"
-          value={displayValue}
-          onChange={handleChange}
-          onBlur={onBlur}
-          placeholder={field.placeholder || '0'}
-          disabled={disabled || field.is_readonly}
-          className={cn(
-            isCurrency && 'pl-8',
-            error && 'border-red-500 focus-visible:ring-red-500',
-            field.is_readonly && 'bg-gray-50 text-gray-500',
-            'text-right'
-          )}
-        />
-      </div>
-
-      {field.help_text && !error && (
-        <p className="text-xs text-muted-foreground">{field.help_text}</p>
+      <Input
+        id={fieldKey}
+        type="number"
+        placeholder={field.placeholder || `${field.field_name}을(를) 입력하세요`}
+        value={stringValue}
+        onChange={(e) => {
+          const newValue = e.target.value;
+          // 빈 문자열이면 null, 아니면 숫자로 변환
+          onChange(newValue === '' ? null : Number(newValue));
+        }}
+        disabled={disabled}
+        step={step}
+        min={field.validation_rules?.min}
+        max={field.validation_rules?.max}
+        className={error ? 'border-red-500' : ''}
+      />
+      {error && (
+        <p className="text-xs text-red-500 mt-1">{error}</p>
+      )}
+      {!error && field.description && (
+        <p className="text-xs text-muted-foreground mt-1">
+          * {field.description}
+        </p>
       )}
-
-      {error && <p className="text-xs text-red-500">{error}</p>}
     </div>
   );
-}
-
-export default NumberField;
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/fields/TextField.tsx b/src/components/items/DynamicItemForm/fields/TextField.tsx
index 0833c89d..66c692b6 100644
--- a/src/components/items/DynamicItemForm/fields/TextField.tsx
+++ b/src/components/items/DynamicItemForm/fields/TextField.tsx
@@ -1,83 +1,47 @@
 /**
- * TextField Component
- *
- * 텍스트 입력 필드 (textbox, textarea)
+ * 텍스트 입력 필드 컴포넌트
+ * 기존 ItemForm과 100% 동일한 디자인
  */
 
 'use client';
 
-import { Input } from '@/components/ui/input';
-import { Textarea } from '@/components/ui/textarea';
 import { Label } from '@/components/ui/label';
-import type { DynamicFieldProps } from '../types';
-import { cn } from '@/lib/utils';
+import { Input } from '@/components/ui/input';
+import type { DynamicFieldRendererProps } from '../types';
 
 export function TextField({
   field,
   value,
-  error,
   onChange,
-  onBlur,
+  error,
   disabled,
-}: DynamicFieldProps) {
-  const isTextarea = field.field_type === 'textarea';
-  const displayValue = value === null || value === undefined ? '' : String(value);
-
-  const handleChange = (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => {
-    onChange(e.target.value);
-  };
+}: DynamicFieldRendererProps) {
+  const fieldKey = field.field_key || `field_${field.id}`;
+  const stringValue = value !== null && value !== undefined ? String(value) : '';
 
   return (
-    <div className="space-y-2">
-      <Label
-        htmlFor={field.field_key}
-        className={cn(
-          'text-sm font-medium',
-          field.is_required && "after:content-['*'] after:ml-0.5 after:text-red-500"
-        )}
-      >
+    <div>
+      <Label htmlFor={fieldKey}>
         {field.field_name}
+        {field.is_required && <span className="text-red-500"> *</span>}
       </Label>
-
-      {isTextarea ? (
-        <Textarea
-          id={field.field_key}
-          name={field.field_key}
-          value={displayValue}
-          onChange={handleChange}
-          onBlur={onBlur}
-          placeholder={field.placeholder}
-          disabled={disabled || field.is_readonly}
-          className={cn(
-            'min-h-[100px]',
-            error && 'border-red-500 focus-visible:ring-red-500'
-          )}
-        />
-      ) : (
-        <Input
-          id={field.field_key}
-          name={field.field_key}
-          type="text"
-          value={displayValue}
-          onChange={handleChange}
-          onBlur={onBlur}
-          placeholder={field.placeholder}
-          disabled={disabled || field.is_readonly}
-          maxLength={field.validation_rules?.maxLength}
-          className={cn(
-            error && 'border-red-500 focus-visible:ring-red-500',
-            field.is_readonly && 'bg-gray-50 text-gray-500'
-          )}
-        />
+      <Input
+        id={fieldKey}
+        type="text"
+        placeholder={field.placeholder || `${field.field_name}을(를) 입력하세요`}
+        value={stringValue}
+        onChange={(e) => onChange(e.target.value)}
+        disabled={disabled}
+        className={error ? 'border-red-500' : ''}
+      />
+      {error && (
+        <p className="text-xs text-red-500 mt-1">{error}</p>
       )}
-
-      {field.help_text && !error && (
-        <p className="text-xs text-muted-foreground">{field.help_text}</p>
+      {!error && field.description && (
+        <p className="text-xs text-muted-foreground mt-1">
+          * {field.description}
+        </p>
       )}
-
-      {error && <p className="text-xs text-red-500">{error}</p>}
     </div>
   );
 }
-
-export default TextField;
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/fields/TextareaField.tsx b/src/components/items/DynamicItemForm/fields/TextareaField.tsx
new file mode 100644
index 00000000..40438b1d
--- /dev/null
+++ b/src/components/items/DynamicItemForm/fields/TextareaField.tsx
@@ -0,0 +1,50 @@
+/**
+ * 텍스트영역(Textarea) 필드 컴포넌트
+ * 기존 ItemForm과 100% 동일한 디자인
+ */
+
+'use client';
+
+import { Label } from '@/components/ui/label';
+import { Textarea } from '@/components/ui/textarea';
+import type { DynamicFieldRendererProps } from '../types';
+
+export function TextareaField({
+  field,
+  value,
+  onChange,
+  error,
+  disabled,
+}: DynamicFieldRendererProps) {
+  const fieldKey = field.field_key || `field_${field.id}`;
+  const stringValue = value !== null && value !== undefined ? String(value) : '';
+
+  // properties에서 rows 추출
+  const rows = field.properties?.rows as number | undefined;
+
+  return (
+    <div className="md:col-span-2">
+      <Label htmlFor={fieldKey}>
+        {field.field_name}
+        {field.is_required && <span className="text-red-500"> *</span>}
+      </Label>
+      <Textarea
+        id={fieldKey}
+        placeholder={field.placeholder || `${field.field_name}을(를) 입력하세요`}
+        value={stringValue}
+        onChange={(e) => onChange(e.target.value)}
+        disabled={disabled}
+        rows={rows || 3}
+        className={error ? 'border-red-500' : ''}
+      />
+      {error && (
+        <p className="text-xs text-red-500 mt-1">{error}</p>
+      )}
+      {!error && field.description && (
+        <p className="text-xs text-muted-foreground mt-1">
+          * {field.description}
+        </p>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/items/DynamicItemForm/fields/index.ts b/src/components/items/DynamicItemForm/fields/index.ts
index fa0eda6a..303c07b6 100644
--- a/src/components/items/DynamicItemForm/fields/index.ts
+++ b/src/components/items/DynamicItemForm/fields/index.ts
@@ -1,11 +1,7 @@
-/**
- * 동적 필드 컴포넌트 인덱스
- */
-
 export { TextField } from './TextField';
-export { DropdownField } from './DropdownField';
 export { NumberField } from './NumberField';
-export { DateField } from './DateField';
+export { DropdownField } from './DropdownField';
 export { CheckboxField } from './CheckboxField';
-export { FileField } from './FileField';
-export { CustomField } from './CustomField';
+export { DateField } from './DateField';
+export { TextareaField } from './TextareaField';
+export { DynamicFieldRenderer } from './DynamicFieldRenderer';
diff --git a/src/components/items/DynamicItemForm/hooks/index.ts b/src/components/items/DynamicItemForm/hooks/index.ts
index dba7ffb4..551b2c99 100644
--- a/src/components/items/DynamicItemForm/hooks/index.ts
+++ b/src/components/items/DynamicItemForm/hooks/index.ts
@@ -1,7 +1,3 @@
-/**
- * 동적 폼 훅 인덱스
- */
-
-export { useFormStructure, clearFormStructureCache, invalidateFormStructureCache } from './useFormStructure';
-export { useConditionalFields } from './useConditionalFields';
+export { useFormStructure } from './useFormStructure';
 export { useDynamicFormState } from './useDynamicFormState';
+export { useConditionalDisplay } from './useConditionalDisplay';
diff --git a/src/components/items/DynamicItemForm/hooks/useConditionalDisplay.ts b/src/components/items/DynamicItemForm/hooks/useConditionalDisplay.ts
new file mode 100644
index 00000000..27498c66
--- /dev/null
+++ b/src/components/items/DynamicItemForm/hooks/useConditionalDisplay.ts
@@ -0,0 +1,205 @@
+/**
+ * 조건부 표시 훅
+ *
+ * display_condition을 기반으로 섹션/필드의 visibility를 결정
+ */
+
+'use client';
+
+import { useMemo } from 'react';
+import type {
+  DynamicFormStructure,
+  DynamicFormData,
+  DisplayCondition,
+  FieldConditionConfig,
+} from '../types';
+
+interface ConditionalDisplayResult {
+  /** 섹션이 표시되어야 하는지 확인 */
+  shouldShowSection: (sectionId: number) => boolean;
+  /** 필드가 표시되어야 하는지 확인 */
+  shouldShowField: (fieldId: number) => boolean;
+  /** 조건부 표시 설정이 있는 트리거 필드 목록 */
+  triggerFields: Array<{
+    fieldKey: string;
+    fieldId: number;
+    condition: DisplayCondition;
+  }>;
+}
+
+/**
+ * 조건부 표시 훅
+ *
+ * @param structure - 폼 구조
+ * @param formData - 현재 폼 데이터
+ * @returns 조건부 표시 관련 함수들
+ */
+export function useConditionalDisplay(
+  structure: DynamicFormStructure | null,
+  formData: DynamicFormData
+): ConditionalDisplayResult {
+  // 조건부 표시 설정이 있는 필드들 수집
+  const triggerFields = useMemo(() => {
+    if (!structure) return [];
+
+    const triggers: ConditionalDisplayResult['triggerFields'] = [];
+
+    // 모든 섹션의 필드 검사
+    structure.sections.forEach((section) => {
+      section.fields.forEach((dynamicField) => {
+        const field = dynamicField.field;
+        if (field.display_condition) {
+          const condition = field.display_condition as DisplayCondition;
+          triggers.push({
+            fieldKey: field.field_key || `field_${field.id}`,
+            fieldId: field.id,
+            condition,
+          });
+        }
+      });
+    });
+
+    // 직접 필드도 검사
+    structure.directFields.forEach((dynamicField) => {
+      const field = dynamicField.field;
+      if (field.display_condition) {
+        const condition = field.display_condition as DisplayCondition;
+        triggers.push({
+          fieldKey: field.field_key || `field_${field.id}`,
+          fieldId: field.id,
+          condition,
+        });
+      }
+    });
+
+    // 디버깅: 조건부 표시 설정 확인
+    console.log('[useConditionalDisplay] 트리거 필드 목록:', triggers.map(t => ({
+      fieldKey: t.fieldKey,
+      fieldId: t.fieldId,
+      fieldConditions: t.condition.fieldConditions?.map(fc => ({
+        expectedValue: fc.expectedValue,
+        targetFieldIds: fc.targetFieldIds,
+        targetSectionIds: fc.targetSectionIds,
+      })),
+    })));
+
+    return triggers;
+  }, [structure]);
+
+  // 현재 활성화된 조건들 계산
+  const activeConditions = useMemo(() => {
+    const activeSectionIds = new Set<string>();
+    const activeFieldIds = new Set<string>();
+
+    // 각 트리거 필드의 현재 값 확인
+    triggerFields.forEach((trigger) => {
+      const currentValue = formData[trigger.fieldKey];
+      const condition = trigger.condition;
+
+      // fieldConditions 배열 순회
+      if (condition.fieldConditions) {
+        condition.fieldConditions.forEach((fc: FieldConditionConfig) => {
+          // 현재 값과 기대값이 일치하는지 확인
+          const isMatch = String(currentValue) === fc.expectedValue;
+
+          // 디버깅: 조건 매칭 확인
+          console.log('[useConditionalDisplay] 조건 매칭 체크:', {
+            triggerFieldKey: trigger.fieldKey,
+            currentValue: String(currentValue),
+            expectedValue: fc.expectedValue,
+            isMatch,
+            targetFieldIds: fc.targetFieldIds,
+          });
+
+          if (isMatch) {
+            // 일치하면 타겟 섹션/필드 활성화
+            if (fc.targetSectionIds) {
+              fc.targetSectionIds.forEach((id) => activeSectionIds.add(id));
+            }
+            if (fc.targetFieldIds) {
+              fc.targetFieldIds.forEach((id) => activeFieldIds.add(id));
+            }
+          }
+        });
+      }
+    });
+
+    console.log('[useConditionalDisplay] 활성화된 필드 ID:', [...activeFieldIds]);
+
+    return { activeSectionIds, activeFieldIds };
+  }, [triggerFields, formData]);
+
+  // 조건부 표시가 적용되는 섹션 ID 목록
+  const conditionalSectionIds = useMemo(() => {
+    const ids = new Set<string>();
+
+    triggerFields.forEach((trigger) => {
+      const condition = trigger.condition;
+      if (condition.fieldConditions) {
+        condition.fieldConditions.forEach((fc: FieldConditionConfig) => {
+          if (fc.targetSectionIds) {
+            fc.targetSectionIds.forEach((id) => ids.add(id));
+          }
+        });
+      }
+    });
+
+    return ids;
+  }, [triggerFields]);
+
+  // 조건부 표시가 적용되는 필드 ID 목록
+  const conditionalFieldIds = useMemo(() => {
+    const ids = new Set<string>();
+
+    triggerFields.forEach((trigger) => {
+      const condition = trigger.condition;
+      if (condition.fieldConditions) {
+        condition.fieldConditions.forEach((fc: FieldConditionConfig) => {
+          if (fc.targetFieldIds) {
+            fc.targetFieldIds.forEach((id) => ids.add(id));
+          }
+        });
+      }
+    });
+
+    return ids;
+  }, [triggerFields]);
+
+  // 섹션 표시 여부 확인
+  const shouldShowSection = useMemo(() => {
+    return (sectionId: number): boolean => {
+      const sectionIdStr = String(sectionId);
+
+      // 이 섹션이 조건부 표시 대상인지 확인
+      if (!conditionalSectionIds.has(sectionIdStr)) {
+        // 조건부 표시 대상이 아니면 항상 표시
+        return true;
+      }
+
+      // 조건부 표시 대상이면 활성화된 섹션인지 확인
+      return activeConditions.activeSectionIds.has(sectionIdStr);
+    };
+  }, [conditionalSectionIds, activeConditions]);
+
+  // 필드 표시 여부 확인
+  const shouldShowField = useMemo(() => {
+    return (fieldId: number): boolean => {
+      const fieldIdStr = String(fieldId);
+
+      // 이 필드가 조건부 표시 대상인지 확인
+      if (!conditionalFieldIds.has(fieldIdStr)) {
+        // 조건부 표시 대상이 아니면 항상 표시
+        return true;
+      }
+
+      // 조건부 표시 대상이면 활성화된 필드인지 확인
+      return activeConditions.activeFieldIds.has(fieldIdStr);
+    };
+  }, [conditionalFieldIds, activeConditions]);
+
+  return {
+    shouldShowSection,
+    shouldShowField,
+    triggerFields,
+  };
+}
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/hooks/useConditionalFields.ts b/src/components/items/DynamicItemForm/hooks/useConditionalFields.ts
deleted file mode 100644
index ccd54783..00000000
--- a/src/components/items/DynamicItemForm/hooks/useConditionalFields.ts
+++ /dev/null
@@ -1,256 +0,0 @@
-/**
- * useConditionalFields Hook
- *
- * 조건부 섹션/필드 표시 로직을 처리하는 훅
- * - 필드 값에 따른 섹션 표시/숨김
- * - 필드 값에 따른 필드 표시/숨김
- * - 조건 평가 (equals, in, not_equals 등)
- */
-
-'use client';
-
-import { useMemo } from 'react';
-import type {
-  ConditionalSection,
-  ConditionalField,
-  DynamicSection,
-  Condition,
-  FormData,
-  UseConditionalFieldsReturn,
-} from '../types';
-
-/**
- * 단일 조건 평가
- */
-function evaluateCondition(condition: Condition, values: FormData): boolean {
-  const fieldValue = values[condition.field_key];
-
-  switch (condition.operator) {
-    case 'equals':
-      return fieldValue === condition.value;
-
-    case 'not_equals':
-      return fieldValue !== condition.value;
-
-    case 'in':
-      if (Array.isArray(condition.value)) {
-        return condition.value.includes(fieldValue as string);
-      }
-      return false;
-
-    case 'not_in':
-      if (Array.isArray(condition.value)) {
-        return !condition.value.includes(fieldValue as string);
-      }
-      return true;
-
-    case 'contains':
-      if (typeof fieldValue === 'string' && typeof condition.value === 'string') {
-        return fieldValue.includes(condition.value);
-      }
-      return false;
-
-    case 'greater_than':
-      if (typeof fieldValue === 'number' && typeof condition.value === 'number') {
-        return fieldValue > condition.value;
-      }
-      return false;
-
-    case 'less_than':
-      if (typeof fieldValue === 'number' && typeof condition.value === 'number') {
-        return fieldValue < condition.value;
-      }
-      return false;
-
-    default:
-      return true;
-  }
-}
-
-/**
- * 섹션의 display_condition 평가
- */
-function isSectionConditionMet(section: DynamicSection, values: FormData): boolean {
-  // display_condition이 없으면 항상 표시
-  if (!section.display_condition) {
-    return true;
-  }
-
-  return evaluateCondition(section.display_condition, values);
-}
-
-/**
- * 조건부 섹션 규칙에 따른 표시 여부 결정
- */
-function evaluateConditionalSections(
-  sections: DynamicSection[],
-  conditionalSections: ConditionalSection[],
-  values: FormData
-): Set<number> {
-  const visibleSectionIds = new Set<number>();
-
-  // 1. 기본적으로 모든 섹션의 display_condition 평가
-  for (const section of sections) {
-    if (isSectionConditionMet(section, values)) {
-      visibleSectionIds.add(section.id);
-    }
-  }
-
-  // 2. conditionalSections 규칙 적용
-  for (const rule of conditionalSections) {
-    const conditionMet = evaluateCondition(rule.condition, values);
-
-    if (conditionMet) {
-      // 조건 충족 시 show_sections 표시
-      for (const sectionId of rule.show_sections) {
-        visibleSectionIds.add(sectionId);
-      }
-      // hide_sections가 있으면 숨김
-      if (rule.hide_sections) {
-        for (const sectionId of rule.hide_sections) {
-          visibleSectionIds.delete(sectionId);
-        }
-      }
-    } else {
-      // 조건 미충족 시 show_sections 숨김
-      for (const sectionId of rule.show_sections) {
-        visibleSectionIds.delete(sectionId);
-      }
-    }
-  }
-
-  return visibleSectionIds;
-}
-
-/**
- * 조건부 필드 규칙에 따른 표시 여부 결정
- */
-function evaluateConditionalFields(
-  sections: DynamicSection[],
-  conditionalFields: ConditionalField[],
-  values: FormData
-): Map<number, Set<number>> {
-  const visibleFieldsMap = new Map<number, Set<number>>();
-
-  // 1. 기본적으로 모든 필드 표시 (각 섹션별로)
-  for (const section of sections) {
-    const fieldIds = new Set<number>();
-
-    for (const field of section.fields) {
-      // 필드의 display_condition 평가
-      if (field.display_condition) {
-        if (evaluateCondition(field.display_condition, values)) {
-          fieldIds.add(field.id);
-        }
-      } else {
-        fieldIds.add(field.id);
-      }
-    }
-
-    visibleFieldsMap.set(section.id, fieldIds);
-  }
-
-  // 2. conditionalFields 규칙 적용
-  for (const rule of conditionalFields) {
-    const conditionMet = evaluateCondition(rule.condition, values);
-
-    // 모든 섹션에서 해당 필드 ID 찾기
-    for (const [sectionId, fieldIds] of visibleFieldsMap) {
-      if (conditionMet) {
-        // 조건 충족 시 show_fields 표시
-        for (const fieldId of rule.show_fields) {
-          fieldIds.add(fieldId);
-        }
-        // hide_fields가 있으면 숨김
-        if (rule.hide_fields) {
-          for (const fieldId of rule.hide_fields) {
-            fieldIds.delete(fieldId);
-          }
-        }
-      } else {
-        // 조건 미충족 시 show_fields 숨김
-        for (const fieldId of rule.show_fields) {
-          fieldIds.delete(fieldId);
-        }
-      }
-    }
-  }
-
-  return visibleFieldsMap;
-}
-
-interface UseConditionalFieldsOptions {
-  sections: DynamicSection[];
-  conditionalSections: ConditionalSection[];
-  conditionalFields: ConditionalField[];
-  values: FormData;
-}
-
-/**
- * useConditionalFields Hook
- *
- * @param options - 훅 옵션
- * @returns 조건부 표시 상태 및 헬퍼 함수
- *
- * @example
- * const { visibleSections, isFieldVisible, isSectionVisible } = useConditionalFields({
- *   sections: formStructure.sections,
- *   conditionalSections: formStructure.conditionalSections,
- *   conditionalFields: formStructure.conditionalFields,
- *   values: formValues,
- * });
- */
-export function useConditionalFields(
-  options: UseConditionalFieldsOptions
-): UseConditionalFieldsReturn {
-  const { sections, conditionalSections, conditionalFields, values } = options;
-
-  // 표시할 섹션 ID 목록
-  const visibleSectionIds = useMemo(() => {
-    return evaluateConditionalSections(sections, conditionalSections, values);
-  }, [sections, conditionalSections, values]);
-
-  // 섹션별 표시할 필드 ID 맵
-  const visibleFieldsMap = useMemo(() => {
-    return evaluateConditionalFields(sections, conditionalFields, values);
-  }, [sections, conditionalFields, values]);
-
-  // 배열로 변환
-  const visibleSections = useMemo(() => {
-    return Array.from(visibleSectionIds);
-  }, [visibleSectionIds]);
-
-  // Map을 Record로 변환
-  const visibleFields = useMemo(() => {
-    const result: Record<number, number[]> = {};
-    for (const [sectionId, fieldIds] of visibleFieldsMap) {
-      result[sectionId] = Array.from(fieldIds);
-    }
-    return result;
-  }, [visibleFieldsMap]);
-
-  /**
-   * 특정 섹션이 표시되는지 확인
-   */
-  const isSectionVisible = (sectionId: number): boolean => {
-    return visibleSectionIds.has(sectionId);
-  };
-
-  /**
-   * 특정 필드가 표시되는지 확인
-   */
-  const isFieldVisible = (sectionId: number, fieldId: number): boolean => {
-    const fieldIds = visibleFieldsMap.get(sectionId);
-    if (!fieldIds) return false;
-    return fieldIds.has(fieldId);
-  };
-
-  return {
-    visibleSections,
-    visibleFields,
-    isSectionVisible,
-    isFieldVisible,
-  };
-}
-
-export default useConditionalFields;
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/hooks/useDynamicFormState.ts b/src/components/items/DynamicItemForm/hooks/useDynamicFormState.ts
index cdee58be..d8add395 100644
--- a/src/components/items/DynamicItemForm/hooks/useDynamicFormState.ts
+++ b/src/components/items/DynamicItemForm/hooks/useDynamicFormState.ts
@@ -1,341 +1,188 @@
 /**
- * useDynamicFormState Hook
+ * 동적 폼 상태 관리 훅
  *
- * 동적 폼의 상태 관리 훅
  * - 필드 값 관리
- * - 유효성 검증
- * - 에러 상태 관리
- * - 폼 제출 처리
+ * - 밸리데이션
+ * - 에러 관리
+ * - 폼 제출
  */
 
 'use client';
 
-import { useState, useCallback, useMemo } from 'react';
+import { useState, useCallback } from 'react';
 import type {
-  FormState,
-  FormData,
-  FormValue,
-  DynamicSection,
-  DynamicField,
-  UseDynamicFormStateReturn,
-  ValidationRules,
-  FIELD_TYPE_DEFAULTS,
+  DynamicFormData,
+  DynamicFormErrors,
+  DynamicFieldValue,
+  UseDynamicFormStateResult,
 } from '../types';
+import type { ItemFieldResponse } from '@/types/item-master-api';
 
-/**
- * 폼 구조에서 초기 값 생성
- */
-function buildInitialValues(
-  sections: DynamicSection[],
-  existingValues?: FormData
-): FormData {
-  const values: FormData = {};
-
-  for (const section of sections) {
-    for (const field of section.fields) {
-      // 기존 값이 있으면 사용, 없으면 기본값
-      if (existingValues && existingValues[field.field_key] !== undefined) {
-        values[field.field_key] = existingValues[field.field_key];
-      } else if (field.default_value !== undefined) {
-        values[field.field_key] = field.default_value;
-      } else {
-        // 필드 타입에 따른 기본값
-        values[field.field_key] = getDefaultValueForType(field.field_type);
-      }
-    }
-  }
-
-  return values;
-}
-
-/**
- * 필드 타입에 따른 기본값
- */
-function getDefaultValueForType(fieldType: string): FormValue {
-  switch (fieldType) {
-    case 'textbox':
-    case 'textarea':
-    case 'dropdown':
-    case 'searchable-dropdown':
-      return '';
-    case 'number':
-    case 'currency':
-      return 0;
-    case 'checkbox':
-    case 'switch':
-      return false;
-    case 'date':
-    case 'date-range':
-    case 'file':
-    case 'custom:drawing-canvas':
-    case 'custom:bending-detail-table':
-    case 'custom:bom-table':
-      return null;
-    default:
-      return '';
-  }
-}
-
-/**
- * 단일 필드 유효성 검증
- */
-function validateField(
-  field: DynamicField,
-  value: FormValue
-): string | undefined {
-  // 필수 필드 검사
-  if (field.is_required) {
-    if (value === null || value === undefined || value === '') {
-      return `${field.field_name}은(는) 필수 입력 항목입니다.`;
-    }
-  }
-
-  // 값이 없으면 추가 검증 스킵
-  if (value === null || value === undefined || value === '') {
-    return undefined;
-  }
-
-  const rules = field.validation_rules;
-  if (!rules) return undefined;
-
-  // 문자열 검증
-  if (typeof value === 'string') {
-    if (rules.minLength && value.length < rules.minLength) {
-      return `최소 ${rules.minLength}자 이상 입력해주세요.`;
-    }
-    if (rules.maxLength && value.length > rules.maxLength) {
-      return `최대 ${rules.maxLength}자까지 입력 가능합니다.`;
-    }
-    if (rules.pattern) {
-      const regex = new RegExp(rules.pattern);
-      if (!regex.test(value)) {
-        return rules.patternMessage || '입력 형식이 올바르지 않습니다.';
-      }
-    }
-  }
-
-  // 숫자 검증
-  if (typeof value === 'number') {
-    if (rules.min !== undefined && value < rules.min) {
-      return `최소 ${rules.min} 이상이어야 합니다.`;
-    }
-    if (rules.max !== undefined && value > rules.max) {
-      return `최대 ${rules.max} 이하여야 합니다.`;
-    }
-  }
-
-  return undefined;
-}
-
-/**
- * 전체 폼 유효성 검증
- */
-function validateForm(
-  sections: DynamicSection[],
-  values: FormData
-): Record<string, string> {
-  const errors: Record<string, string> = {};
-
-  for (const section of sections) {
-    for (const field of section.fields) {
-      const error = validateField(field, values[field.field_key]);
-      if (error) {
-        errors[field.field_key] = error;
-      }
-    }
-  }
-
-  return errors;
-}
-
-interface UseDynamicFormStateOptions {
-  sections: DynamicSection[];
-  initialValues?: FormData;
-  onSubmit?: (data: FormData) => Promise<void>;
-}
-
-/**
- * useDynamicFormState Hook
- *
- * @param options - 훅 옵션
- * @returns 폼 상태 및 조작 함수
- *
- * @example
- * const { state, setValue, handleSubmit, validate } = useDynamicFormState({
- *   sections: formStructure.sections,
- *   initialValues: existingItem,
- *   onSubmit: async (data) => {
- *     await saveItem(data);
- *   },
- * });
- */
 export function useDynamicFormState(
-  options: UseDynamicFormStateOptions
-): UseDynamicFormStateReturn {
-  const { sections, initialValues, onSubmit } = options;
+  initialData?: DynamicFormData
+): UseDynamicFormStateResult {
+  const [formData, setFormData] = useState<DynamicFormData>(initialData || {});
+  const [errors, setErrors] = useState<DynamicFormErrors>({});
+  const [isSubmitting, setIsSubmitting] = useState(false);
 
-  // 초기 상태 생성
-  const [state, setState] = useState<FormState>(() => ({
-    values: buildInitialValues(sections, initialValues),
-    errors: {},
-    touched: {},
-    isSubmitting: false,
-    isValid: true,
-  }));
-
-  /**
-   * 단일 필드 값 설정
-   */
-  const setValue = useCallback((fieldKey: string, value: FormValue) => {
-    setState((prev) => ({
+  // 필드 값 설정
+  const setFieldValue = useCallback((fieldKey: string, value: DynamicFieldValue) => {
+    setFormData((prev) => ({
       ...prev,
-      values: {
-        ...prev.values,
-        [fieldKey]: value,
-      },
-      // 값 변경 시 해당 필드 에러 클리어
-      errors: {
-        ...prev.errors,
-        [fieldKey]: undefined as unknown as string,
-      },
+      [fieldKey]: value,
     }));
-  }, []);
-
-  /**
-   * 여러 필드 값 일괄 설정
-   */
-  const setValues = useCallback((values: FormData) => {
-    setState((prev) => ({
-      ...prev,
-      values: {
-        ...prev.values,
-        ...values,
-      },
-    }));
-  }, []);
-
-  /**
-   * 필드 에러 설정
-   */
-  const setError = useCallback((fieldKey: string, message: string) => {
-    setState((prev) => ({
-      ...prev,
-      errors: {
-        ...prev.errors,
-        [fieldKey]: message,
-      },
-      isValid: false,
-    }));
-  }, []);
-
-  /**
-   * 필드 에러 클리어
-   */
-  const clearError = useCallback((fieldKey: string) => {
-    setState((prev) => {
-      const newErrors = { ...prev.errors };
+    // 값이 변경되면 해당 필드의 에러 제거
+    setErrors((prev) => {
+      const newErrors = { ...prev };
       delete newErrors[fieldKey];
-      return {
-        ...prev,
-        errors: newErrors,
-        isValid: Object.keys(newErrors).length === 0,
-      };
+      return newErrors;
     });
   }, []);
 
-  /**
-   * 필드 touched 상태 설정
-   */
-  const setTouched = useCallback((fieldKey: string) => {
-    setState((prev) => ({
+  // 에러 설정
+  const setError = useCallback((fieldKey: string, error: string) => {
+    setErrors((prev) => ({
       ...prev,
-      touched: {
-        ...prev.touched,
-        [fieldKey]: true,
-      },
+      [fieldKey]: error,
     }));
   }, []);
 
-  /**
-   * 전체 폼 유효성 검증
-   */
-  const validate = useCallback((): boolean => {
-    const errors = validateForm(sections, state.values);
-    const isValid = Object.keys(errors).length === 0;
+  // 에러 제거
+  const clearError = useCallback((fieldKey: string) => {
+    setErrors((prev) => {
+      const newErrors = { ...prev };
+      delete newErrors[fieldKey];
+      return newErrors;
+    });
+  }, []);
 
-    setState((prev) => ({
-      ...prev,
-      errors,
-      isValid,
-    }));
+  // 모든 에러 제거
+  const clearAllErrors = useCallback(() => {
+    setErrors({});
+  }, []);
 
-    return isValid;
-  }, [sections, state.values]);
+  // 단일 필드 밸리데이션
+  const validateField = useCallback(
+    (field: ItemFieldResponse, value: DynamicFieldValue): string | null => {
+      const fieldKey = field.field_key || `field_${field.id}`;
 
-  /**
-   * 폼 리셋
-   */
-  const reset = useCallback(
-    (resetValues?: FormData) => {
-      setState({
-        values: buildInitialValues(sections, resetValues || initialValues),
-        errors: {},
-        touched: {},
-        isSubmitting: false,
-        isValid: true,
-      });
+      // 필수 필드 체크
+      if (field.is_required) {
+        if (value === null || value === undefined || value === '') {
+          return `${field.field_name}은(는) 필수 입력 항목입니다.`;
+        }
+      }
+
+      // 값이 없으면 추가 검증 스킵
+      if (value === null || value === undefined || value === '') {
+        return null;
+      }
+
+      // validation_rules 적용
+      const rules = field.validation_rules;
+      if (rules) {
+        // min 검증 (숫자)
+        if (rules.min !== undefined && field.field_type === 'number') {
+          const numValue = Number(value);
+          if (numValue < rules.min) {
+            return `${field.field_name}은(는) ${rules.min} 이상이어야 합니다.`;
+          }
+        }
+
+        // max 검증 (숫자)
+        if (rules.max !== undefined && field.field_type === 'number') {
+          const numValue = Number(value);
+          if (numValue > rules.max) {
+            return `${field.field_name}은(는) ${rules.max} 이하여야 합니다.`;
+          }
+        }
+
+        // minLength 검증 (문자열)
+        if (rules.minLength !== undefined && typeof value === 'string') {
+          if (value.length < rules.minLength) {
+            return `${field.field_name}은(는) ${rules.minLength}자 이상이어야 합니다.`;
+          }
+        }
+
+        // maxLength 검증 (문자열)
+        if (rules.maxLength !== undefined && typeof value === 'string') {
+          if (value.length > rules.maxLength) {
+            return `${field.field_name}은(는) ${rules.maxLength}자 이하여야 합니다.`;
+          }
+        }
+
+        // pattern 검증 (정규식)
+        if (rules.pattern && typeof value === 'string') {
+          const regex = new RegExp(rules.pattern);
+          if (!regex.test(value)) {
+            return rules.patternMessage || `${field.field_name}의 형식이 올바르지 않습니다.`;
+          }
+        }
+      }
+
+      return null;
     },
-    [sections, initialValues]
+    []
   );
 
-  /**
-   * 폼 제출 핸들러 생성
-   */
+  // 전체 필드 밸리데이션
+  const validateAll = useCallback(
+    (fields: ItemFieldResponse[]): boolean => {
+      const newErrors: DynamicFormErrors = {};
+      let isValid = true;
+
+      for (const field of fields) {
+        const fieldKey = field.field_key || `field_${field.id}`;
+        const value = formData[fieldKey];
+        const error = validateField(field, value);
+
+        if (error) {
+          newErrors[fieldKey] = error;
+          isValid = false;
+        }
+      }
+
+      setErrors(newErrors);
+      return isValid;
+    },
+    [formData, validateField]
+  );
+
+  // 폼 제출
   const handleSubmit = useCallback(
-    (submitFn: (data: FormData) => Promise<void>) => {
-      return async (e: React.FormEvent) => {
-        e.preventDefault();
+    async (onSubmit: (data: DynamicFormData) => Promise<void>) => {
+      setIsSubmitting(true);
 
-        // 유효성 검증
-        const isValid = validate();
-        if (!isValid) {
-          console.warn('[useDynamicFormState] Form validation failed');
-          return;
-        }
-
-        // 제출 시작
-        setState((prev) => ({
-          ...prev,
-          isSubmitting: true,
-        }));
-
-        try {
-          await submitFn(state.values);
-        } catch (error) {
-          console.error('[useDynamicFormState] Submit error:', error);
-          throw error;
-        } finally {
-          setState((prev) => ({
-            ...prev,
-            isSubmitting: false,
-          }));
-        }
-      };
+      try {
+        await onSubmit(formData);
+      } catch (err) {
+        console.error('폼 제출 실패:', err);
+        throw err;
+      } finally {
+        setIsSubmitting(false);
+      }
     },
-    [validate, state.values]
+    [formData]
   );
 
+  // 폼 초기화
+  const resetForm = useCallback((newInitialData?: DynamicFormData) => {
+    setFormData(newInitialData || {});
+    setErrors({});
+    setIsSubmitting(false);
+  }, []);
+
   return {
-    state,
-    setValue,
-    setValues,
+    formData,
+    errors,
+    isSubmitting,
+    setFieldValue,
     setError,
     clearError,
-    setTouched,
-    validate,
-    reset,
+    clearAllErrors,
+    validateField,
+    validateAll,
     handleSubmit,
+    resetForm,
   };
 }
-
-export default useDynamicFormState;
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/hooks/useFormStructure.ts b/src/components/items/DynamicItemForm/hooks/useFormStructure.ts
index 212956c4..a25f3ba4 100644
--- a/src/components/items/DynamicItemForm/hooks/useFormStructure.ts
+++ b/src/components/items/DynamicItemForm/hooks/useFormStructure.ts
@@ -1,995 +1,95 @@
 /**
- * useFormStructure Hook
+ * 품목기준관리 API에서 폼 구조를 로드하는 훅
  *
- * API에서 품목 유형별 폼 구조를 로드하는 훅
- * - 캐싱 지원 (5분 TTL)
- * - 에러 처리 및 재시도
- * - Mock 데이터 폴백 (API 미구현 시)
+ * - init API에서 페이지 목록 조회
+ * - 품목 유형(itemType)에 해당하는 페이지 찾기
+ * - 해당 페이지의 전체 구조(섹션, 필드) 로드
  */
 
 'use client';
 
-import { useState, useEffect, useCallback, useRef } from 'react';
-import type { ItemType, PartType } from '@/types/item';
+import { useState, useEffect, useCallback } from 'react';
+import { itemMasterApi } from '@/lib/api/item-master';
 import type {
-  FormStructure,
-  FormStructureResponse,
-  UseFormStructureReturn,
-  DynamicSection,
-  DynamicField,
-  ConditionalSection,
+  DynamicFormStructure,
+  UseFormStructureResult,
+  SimpleUnitOption,
 } from '../types';
+import { convertToFormStructure } from '../types';
 
-// ===== 캐시 설정 =====
-const CACHE_TTL = 5 * 60 * 1000; // 5분
-const formStructureCache = new Map<string, { data: FormStructure; timestamp: number }>();
-
-/**
- * 캐시 키 생성
- */
-function getCacheKey(itemType: ItemType, partType?: PartType): string {
-  return partType ? `${itemType}_${partType}` : itemType;
-}
-
-/**
- * 캐시에서 데이터 가져오기
- */
-function getFromCache(key: string): FormStructure | null {
-  const cached = formStructureCache.get(key);
-  if (!cached) return null;
-
-  const isExpired = Date.now() - cached.timestamp > CACHE_TTL;
-  if (isExpired) {
-    formStructureCache.delete(key);
-    return null;
-  }
-
-  return cached.data;
-}
-
-/**
- * 캐시에 데이터 저장
- */
-function setToCache(key: string, data: FormStructure): void {
-  formStructureCache.set(key, { data, timestamp: Date.now() });
-}
-
-// ===== Mock 데이터 (API 미구현 시 사용) =====
-
-/**
- * 제품(FG) Mock 폼 구조
- */
-function getMockFGFormStructure(): FormStructure {
-  return {
-    page: {
-      id: 1,
-      page_name: '제품 등록',
-      item_type: 'FG',
-      is_active: true,
-    },
-    sections: [
-      {
-        id: 101,
-        title: '기본 정보',
-        section_type: 'BASIC',
-        order_no: 1,
-        is_collapsible: false,
-        is_default_open: true,
-        fields: [
-          {
-            id: 1001,
-            field_name: '품목코드',
-            field_key: 'item_code',
-            field_type: 'textbox',
-            order_no: 1,
-            is_required: true,
-            is_readonly: true,
-            placeholder: '자동 생성',
-            grid_row: 1,
-            grid_col: 1,
-            grid_span: 1,
-          },
-          {
-            id: 1002,
-            field_name: '품목명',
-            field_key: 'item_name',
-            field_type: 'textbox',
-            order_no: 2,
-            is_required: true,
-            placeholder: '품목명을 입력하세요',
-            validation_rules: { maxLength: 100 },
-            grid_row: 1,
-            grid_col: 2,
-            grid_span: 2,
-          },
-          {
-            id: 1003,
-            field_name: '제품 카테고리',
-            field_key: 'product_category',
-            field_type: 'dropdown',
-            order_no: 3,
-            is_required: true,
-            dropdown_config: {
-              options: [
-                { value: 'SCREEN', label: '스크린' },
-                { value: 'STEEL', label: '철재' },
-              ],
-              placeholder: '카테고리 선택',
-            },
-            grid_row: 1,
-            grid_col: 4,
-            grid_span: 1,
-          },
-          {
-            id: 1004,
-            field_name: '단위',
-            field_key: 'unit',
-            field_type: 'dropdown',
-            order_no: 4,
-            is_required: true,
-            dropdown_config: {
-              options: [
-                { value: 'EA', label: 'EA (개)' },
-                { value: 'SET', label: 'SET (세트)' },
-              ],
-              placeholder: '단위 선택',
-            },
-            grid_row: 2,
-            grid_col: 1,
-            grid_span: 1,
-          },
-          {
-            id: 1005,
-            field_name: '규격',
-            field_key: 'specification',
-            field_type: 'textbox',
-            order_no: 5,
-            is_required: false,
-            placeholder: '규격을 입력하세요',
-            grid_row: 2,
-            grid_col: 2,
-            grid_span: 2,
-          },
-          {
-            id: 1006,
-            field_name: '활성 상태',
-            field_key: 'is_active',
-            field_type: 'switch',
-            order_no: 6,
-            is_required: false,
-            default_value: true,
-            grid_row: 2,
-            grid_col: 4,
-            grid_span: 1,
-          },
-        ],
-      },
-      {
-        id: 102,
-        title: '가격 정보',
-        section_type: 'DETAIL',
-        order_no: 2,
-        is_collapsible: true,
-        is_default_open: true,
-        fields: [
-          {
-            id: 1010,
-            field_name: '판매 단가',
-            field_key: 'sales_price',
-            field_type: 'currency',
-            order_no: 1,
-            is_required: false,
-            placeholder: '0',
-            grid_row: 1,
-            grid_col: 1,
-            grid_span: 1,
-          },
-          {
-            id: 1011,
-            field_name: '구매 단가',
-            field_key: 'purchase_price',
-            field_type: 'currency',
-            order_no: 2,
-            is_required: false,
-            placeholder: '0',
-            grid_row: 1,
-            grid_col: 2,
-            grid_span: 1,
-          },
-          {
-            id: 1012,
-            field_name: '마진율 (%)',
-            field_key: 'margin_rate',
-            field_type: 'number',
-            order_no: 3,
-            is_required: false,
-            placeholder: '0',
-            validation_rules: { min: 0, max: 100 },
-            grid_row: 1,
-            grid_col: 3,
-            grid_span: 1,
-          },
-        ],
-      },
-      {
-        id: 103,
-        title: '부품 구성 (BOM)',
-        section_type: 'BOM',
-        order_no: 3,
-        is_collapsible: true,
-        is_default_open: true,
-        fields: [],
-        bom_config: {
-          columns: [
-            { key: 'child_item_code', label: '품목코드', width: 150 },
-            { key: 'child_item_name', label: '품목명', width: 200 },
-            { key: 'specification', label: '규격', width: 150 },
-            { key: 'quantity', label: '수량', width: 80, type: 'number', editable: true },
-            { key: 'unit', label: '단위', width: 80 },
-            { key: 'note', label: '비고', width: 150, type: 'text', editable: true },
-          ],
-          allow_search: true,
-          search_endpoint: '/api/proxy/items/search',
-          allow_add: true,
-          allow_delete: true,
-          allow_reorder: true,
-        },
-      },
-      {
-        id: 104,
-        title: '인정 정보',
-        section_type: 'CERTIFICATION',
-        order_no: 4,
-        is_collapsible: true,
-        is_default_open: false,
-        fields: [
-          {
-            id: 1020,
-            field_name: '인정번호',
-            field_key: 'certification_number',
-            field_type: 'textbox',
-            order_no: 1,
-            is_required: false,
-            placeholder: '인정번호를 입력하세요',
-            grid_row: 1,
-            grid_col: 1,
-            grid_span: 2,
-          },
-          {
-            id: 1021,
-            field_name: '인정 시작일',
-            field_key: 'certification_start_date',
-            field_type: 'date',
-            order_no: 2,
-            is_required: false,
-            grid_row: 1,
-            grid_col: 3,
-            grid_span: 1,
-          },
-          {
-            id: 1022,
-            field_name: '인정 종료일',
-            field_key: 'certification_end_date',
-            field_type: 'date',
-            order_no: 3,
-            is_required: false,
-            grid_row: 1,
-            grid_col: 4,
-            grid_span: 1,
-          },
-          {
-            id: 1023,
-            field_name: '시방서',
-            field_key: 'specification_file',
-            field_type: 'file',
-            order_no: 4,
-            is_required: false,
-            file_config: {
-              accept: '.pdf,.doc,.docx',
-              max_size: 10 * 1024 * 1024, // 10MB
-            },
-            grid_row: 2,
-            grid_col: 1,
-            grid_span: 2,
-          },
-          {
-            id: 1024,
-            field_name: '인정서',
-            field_key: 'certification_file',
-            field_type: 'file',
-            order_no: 5,
-            is_required: false,
-            file_config: {
-              accept: '.pdf,.doc,.docx',
-              max_size: 10 * 1024 * 1024,
-            },
-            grid_row: 2,
-            grid_col: 3,
-            grid_span: 2,
-          },
-        ],
-      },
-    ],
-    conditionalSections: [],
-    conditionalFields: [],
-  };
-}
-
-/**
- * 부품(PT) Mock 폼 구조
- */
-function getMockPTFormStructure(partType?: PartType): FormStructure {
-  const baseFields: DynamicField[] = [
-    {
-      id: 2001,
-      field_name: '품목코드',
-      field_key: 'item_code',
-      field_type: 'textbox',
-      order_no: 1,
-      is_required: true,
-      is_readonly: true,
-      placeholder: '자동 생성',
-      grid_row: 1,
-      grid_col: 1,
-      grid_span: 1,
-    },
-    {
-      id: 2002,
-      field_name: '품목명',
-      field_key: 'item_name',
-      field_type: 'textbox',
-      order_no: 2,
-      is_required: true,
-      placeholder: '품목명을 입력하세요',
-      grid_row: 1,
-      grid_col: 2,
-      grid_span: 2,
-    },
-    {
-      id: 2003,
-      field_name: '부품 유형',
-      field_key: 'part_type',
-      field_type: 'dropdown',
-      order_no: 3,
-      is_required: true,
-      dropdown_config: {
-        options: [
-          { value: 'ASSEMBLY', label: '조립 부품' },
-          { value: 'BENDING', label: '절곡 부품' },
-          { value: 'PURCHASED', label: '구매 부품' },
-        ],
-        placeholder: '부품 유형 선택',
-      },
-      grid_row: 1,
-      grid_col: 4,
-      grid_span: 1,
-    },
-    {
-      id: 2004,
-      field_name: '단위',
-      field_key: 'unit',
-      field_type: 'dropdown',
-      order_no: 4,
-      is_required: true,
-      dropdown_config: {
-        options: [
-          { value: 'EA', label: 'EA (개)' },
-          { value: 'SET', label: 'SET (세트)' },
-          { value: 'M', label: 'M (미터)' },
-        ],
-      },
-      grid_row: 2,
-      grid_col: 1,
-      grid_span: 1,
-    },
-  ];
-
-  const sections: DynamicSection[] = [
-    {
-      id: 201,
-      title: '기본 정보',
-      section_type: 'BASIC',
-      order_no: 1,
-      is_collapsible: false,
-      is_default_open: true,
-      fields: baseFields,
-    },
-  ];
-
-  // 조립 부품 전용 섹션
-  const assemblySection: DynamicSection = {
-    id: 202,
-    title: '조립 부품 상세',
-    section_type: 'DETAIL',
-    order_no: 2,
-    is_collapsible: true,
-    is_default_open: true,
-    display_condition: {
-      field_key: 'part_type',
-      operator: 'equals',
-      value: 'ASSEMBLY',
-    },
-    fields: [
-      {
-        id: 2010,
-        field_name: '설치 유형',
-        field_key: 'installation_type',
-        field_type: 'dropdown',
-        order_no: 1,
-        is_required: false,
-        dropdown_config: {
-          options: [
-            { value: 'WALL', label: '벽면형' },
-            { value: 'SIDE', label: '측면형' },
-          ],
-        },
-        grid_row: 1,
-        grid_col: 1,
-        grid_span: 1,
-      },
-      {
-        id: 2011,
-        field_name: '조립 종류',
-        field_key: 'assembly_type',
-        field_type: 'dropdown',
-        order_no: 2,
-        is_required: false,
-        dropdown_config: {
-          options: [
-            { value: 'M', label: 'M형' },
-            { value: 'T', label: 'T형' },
-            { value: 'C', label: 'C형' },
-            { value: 'D', label: 'D형' },
-            { value: 'S', label: 'S형' },
-            { value: 'U', label: 'U형' },
-          ],
-        },
-        grid_row: 1,
-        grid_col: 2,
-        grid_span: 1,
-      },
-      {
-        id: 2012,
-        field_name: '길이 (mm)',
-        field_key: 'assembly_length',
-        field_type: 'dropdown',
-        order_no: 3,
-        is_required: false,
-        dropdown_config: {
-          options: [
-            { value: '2438', label: '2438' },
-            { value: '3000', label: '3000' },
-            { value: '3500', label: '3500' },
-            { value: '4000', label: '4000' },
-            { value: '4300', label: '4300' },
-          ],
-        },
-        grid_row: 1,
-        grid_col: 3,
-        grid_span: 1,
-      },
-    ],
-  };
-
-  // 절곡 부품 전용 섹션
-  const bendingSection: DynamicSection = {
-    id: 203,
-    title: '절곡 정보',
-    section_type: 'BENDING',
-    order_no: 2,
-    is_collapsible: true,
-    is_default_open: true,
-    display_condition: {
-      field_key: 'part_type',
-      operator: 'equals',
-      value: 'BENDING',
-    },
-    fields: [
-      {
-        id: 2020,
-        field_name: '재질',
-        field_key: 'material',
-        field_type: 'dropdown',
-        order_no: 1,
-        is_required: true,
-        dropdown_config: {
-          options: [
-            { value: 'EGI_1.55T', label: 'EGI 1.55T' },
-            { value: 'SUS_1.2T', label: 'SUS 1.2T' },
-            { value: 'SUS_1.5T', label: 'SUS 1.5T' },
-          ],
-        },
-        grid_row: 1,
-        grid_col: 1,
-        grid_span: 1,
-      },
-      {
-        id: 2021,
-        field_name: '길이/목함 (mm)',
-        field_key: 'bending_length',
-        field_type: 'number',
-        order_no: 2,
-        is_required: false,
-        placeholder: '길이 입력',
-        grid_row: 1,
-        grid_col: 2,
-        grid_span: 1,
-      },
-      {
-        id: 2022,
-        field_name: '전개도',
-        field_key: 'bending_diagram',
-        field_type: 'custom:drawing-canvas',
-        order_no: 3,
-        is_required: false,
-        grid_row: 2,
-        grid_col: 1,
-        grid_span: 4,
-      },
-      {
-        id: 2023,
-        field_name: '전개도 상세',
-        field_key: 'bending_details',
-        field_type: 'custom:bending-detail-table',
-        order_no: 4,
-        is_required: false,
-        grid_row: 3,
-        grid_col: 1,
-        grid_span: 4,
-      },
-    ],
-  };
-
-  // 구매 부품 전용 섹션
-  const purchasedSection: DynamicSection = {
-    id: 204,
-    title: '구매 부품 상세',
-    section_type: 'DETAIL',
-    order_no: 2,
-    is_collapsible: true,
-    is_default_open: true,
-    display_condition: {
-      field_key: 'part_type',
-      operator: 'equals',
-      value: 'PURCHASED',
-    },
-    fields: [
-      {
-        id: 2030,
-        field_name: '구매처',
-        field_key: 'supplier',
-        field_type: 'textbox',
-        order_no: 1,
-        is_required: false,
-        placeholder: '구매처를 입력하세요',
-        grid_row: 1,
-        grid_col: 1,
-        grid_span: 2,
-      },
-      {
-        id: 2031,
-        field_name: '구매 단가',
-        field_key: 'purchase_price',
-        field_type: 'currency',
-        order_no: 2,
-        is_required: false,
-        grid_row: 1,
-        grid_col: 3,
-        grid_span: 1,
-      },
-      {
-        id: 2032,
-        field_name: '리드타임 (일)',
-        field_key: 'lead_time',
-        field_type: 'number',
-        order_no: 3,
-        is_required: false,
-        placeholder: '0',
-        grid_row: 1,
-        grid_col: 4,
-        grid_span: 1,
-      },
-    ],
-  };
-
-  sections.push(assemblySection, bendingSection, purchasedSection);
-
-  // BOM 섹션 (조립/절곡 부품만)
-  const bomSection: DynamicSection = {
-    id: 205,
-    title: '부품 구성 (BOM)',
-    section_type: 'BOM',
-    order_no: 3,
-    is_collapsible: true,
-    is_default_open: true,
-    display_condition: {
-      field_key: 'part_type',
-      operator: 'in',
-      value: ['ASSEMBLY', 'BENDING'],
-    },
-    fields: [],
-    bom_config: {
-      columns: [
-        { key: 'child_item_code', label: '품목코드', width: 150 },
-        { key: 'child_item_name', label: '품목명', width: 200 },
-        { key: 'quantity', label: '수량', width: 80, type: 'number', editable: true },
-        { key: 'unit', label: '단위', width: 80 },
-      ],
-      allow_search: true,
-      search_endpoint: '/api/proxy/items/search',
-      allow_add: true,
-      allow_delete: true,
-    },
-  };
-
-  sections.push(bomSection);
-
-  return {
-    page: {
-      id: 2,
-      page_name: '부품 등록',
-      item_type: 'PT',
-      part_type: partType,
-      is_active: true,
-    },
-    sections,
-    conditionalSections: [],
-    conditionalFields: [],
-  };
-}
-
-/**
- * 자재(RM/SM/CS) Mock 폼 구조
- */
-function getMockMaterialFormStructure(itemType: ItemType): FormStructure {
-  const typeLabels: Record<string, string> = {
-    RM: '원자재',
-    SM: '부자재',
-    CS: '소모품',
-  };
-
-  return {
-    page: {
-      id: itemType === 'RM' ? 3 : itemType === 'SM' ? 4 : 5,
-      page_name: `${typeLabels[itemType]} 등록`,
-      item_type: itemType,
-      is_active: true,
-    },
-    sections: [
-      {
-        id: 301,
-        title: '기본 정보',
-        section_type: 'BASIC',
-        order_no: 1,
-        is_collapsible: false,
-        is_default_open: true,
-        fields: [
-          {
-            id: 3001,
-            field_name: '품목코드',
-            field_key: 'item_code',
-            field_type: 'textbox',
-            order_no: 1,
-            is_required: true,
-            is_readonly: true,
-            placeholder: '자동 생성',
-            grid_row: 1,
-            grid_col: 1,
-            grid_span: 1,
-          },
-          {
-            id: 3002,
-            field_name: '품목명',
-            field_key: 'item_name',
-            field_type: 'textbox',
-            order_no: 2,
-            is_required: true,
-            placeholder: '품목명을 입력하세요',
-            grid_row: 1,
-            grid_col: 2,
-            grid_span: 2,
-          },
-          {
-            id: 3003,
-            field_name: '단위',
-            field_key: 'unit',
-            field_type: 'dropdown',
-            order_no: 3,
-            is_required: true,
-            dropdown_config: {
-              options: [
-                { value: 'EA', label: 'EA (개)' },
-                { value: 'KG', label: 'KG (킬로그램)' },
-                { value: 'M', label: 'M (미터)' },
-                { value: 'L', label: 'L (리터)' },
-                { value: 'BOX', label: 'BOX (박스)' },
-              ],
-            },
-            grid_row: 1,
-            grid_col: 4,
-            grid_span: 1,
-          },
-          {
-            id: 3004,
-            field_name: '규격',
-            field_key: 'specification',
-            field_type: 'textbox',
-            order_no: 4,
-            is_required: false,
-            placeholder: '규격을 입력하세요',
-            grid_row: 2,
-            grid_col: 1,
-            grid_span: 2,
-          },
-          {
-            id: 3005,
-            field_name: '구매 단가',
-            field_key: 'purchase_price',
-            field_type: 'currency',
-            order_no: 5,
-            is_required: false,
-            grid_row: 2,
-            grid_col: 3,
-            grid_span: 1,
-          },
-          {
-            id: 3006,
-            field_name: '안전재고',
-            field_key: 'safety_stock',
-            field_type: 'number',
-            order_no: 6,
-            is_required: false,
-            placeholder: '0',
-            grid_row: 2,
-            grid_col: 4,
-            grid_span: 1,
-          },
-        ],
-      },
-      {
-        id: 302,
-        title: '구매 정보',
-        section_type: 'DETAIL',
-        order_no: 2,
-        is_collapsible: true,
-        is_default_open: false,
-        fields: [
-          {
-            id: 3010,
-            field_name: '구매처',
-            field_key: 'supplier',
-            field_type: 'textbox',
-            order_no: 1,
-            is_required: false,
-            placeholder: '구매처를 입력하세요',
-            grid_row: 1,
-            grid_col: 1,
-            grid_span: 2,
-          },
-          {
-            id: 3011,
-            field_name: '리드타임 (일)',
-            field_key: 'lead_time',
-            field_type: 'number',
-            order_no: 2,
-            is_required: false,
-            placeholder: '0',
-            grid_row: 1,
-            grid_col: 3,
-            grid_span: 1,
-          },
-          {
-            id: 3012,
-            field_name: '비고',
-            field_key: 'note',
-            field_type: 'textarea',
-            order_no: 3,
-            is_required: false,
-            placeholder: '비고를 입력하세요',
-            grid_row: 2,
-            grid_col: 1,
-            grid_span: 4,
-          },
-        ],
-      },
-    ],
-    conditionalSections: [],
-    conditionalFields: [],
-  };
-}
-
-/**
- * Mock 데이터 가져오기
- */
-function getMockFormStructure(itemType: ItemType, partType?: PartType): FormStructure {
-  switch (itemType) {
-    case 'FG':
-      return getMockFGFormStructure();
-    case 'PT':
-      return getMockPTFormStructure(partType);
-    case 'RM':
-    case 'SM':
-    case 'CS':
-      return getMockMaterialFormStructure(itemType);
-    default:
-      return getMockFGFormStructure();
-  }
-}
-
-// ===== API 호출 =====
-
-/**
- * 폼 구조 API 호출
- */
-async function fetchFormStructure(
-  itemType: ItemType,
-  partType?: PartType
-): Promise<FormStructure> {
-  const endpoint = partType
-    ? `/api/proxy/item-master/form-structure/${itemType}?part_type=${partType}`
-    : `/api/proxy/item-master/form-structure/${itemType}`;
-
-  try {
-    const response = await fetch(endpoint);
-
-    if (!response.ok) {
-      // API가 404면 Mock 데이터 사용
-      if (response.status === 404) {
-        console.warn(`[useFormStructure] API not found, using mock data for ${itemType}`);
-        return getMockFormStructure(itemType, partType);
-      }
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-
-    const result: FormStructureResponse = await response.json();
-
-    if (!result.success) {
-      throw new Error(result.message || 'API returned unsuccessful response');
-    }
-
-    // API 응답을 FormStructure 형식으로 변환
-    return {
-      page: result.data.page,
-      sections: result.data.sections,
-      conditionalSections: result.data.conditional_sections || [],
-      conditionalFields: result.data.conditional_fields || [],
-    };
-  } catch (error) {
-    console.warn(`[useFormStructure] API call failed, using mock data:`, error);
-    // API 실패 시 Mock 데이터 폴백
-    return getMockFormStructure(itemType, partType);
-  }
-}
-
-// ===== 훅 구현 =====
-
-interface UseFormStructureOptions {
-  itemType: ItemType;
-  partType?: PartType;
-  enabled?: boolean;
-  useMock?: boolean; // 강제로 Mock 데이터 사용
-}
-
-/**
- * useFormStructure Hook
- *
- * @param options - 훅 옵션
- * @returns 폼 구조 데이터 및 상태
- *
- * @example
- * const { formStructure, isLoading, error, refetch } = useFormStructure({
- *   itemType: 'FG',
- * });
- *
- * @example
- * const { formStructure } = useFormStructure({
- *   itemType: 'PT',
- *   partType: 'BENDING',
- * });
- */
-export function useFormStructure(options: UseFormStructureOptions): UseFormStructureReturn {
-  const { itemType, partType, enabled = true, useMock = false } = options;
-
-  const [formStructure, setFormStructure] = useState<FormStructure | null>(null);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-
-  // 이전 요청 취소용
-  const abortControllerRef = useRef<AbortController | null>(null);
-
-  const cacheKey = getCacheKey(itemType, partType);
-
-  /**
-   * 폼 구조 로드
-   */
-  const loadFormStructure = useCallback(async () => {
-    // 이전 요청 취소
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort();
-    }
-    abortControllerRef.current = new AbortController();
-
-    // 캐시 확인
-    const cached = getFromCache(cacheKey);
-    if (cached) {
-      setFormStructure(cached);
-      setIsLoading(false);
-      setError(null);
-      return;
-    }
+export function useFormStructure(
+  itemType: 'FG' | 'PT' | 'SM' | 'RM' | 'CS'
+): UseFormStructureResult {
+  const [structure, setStructure] = useState<DynamicFormStructure | null>(null);
+  const [unitOptions, setUnitOptions] = useState<SimpleUnitOption[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
 
+  const loadStructure = useCallback(async () => {
     setIsLoading(true);
     setError(null);
 
     try {
-      let data: FormStructure;
+      // 1. init API에서 전체 데이터 로드
+      const initData = await itemMasterApi.init();
 
-      if (useMock) {
-        // 강제 Mock 모드
-        data = getMockFormStructure(itemType, partType);
-      } else {
-        // API 호출 (실패 시 자동으로 Mock 폴백)
-        data = await fetchFormStructure(itemType, partType);
+      // 단위 옵션 저장 (SimpleUnitOption 형식으로 변환)
+      console.log('[useFormStructure] API initData.unitOptions:', initData.unitOptions);
+      const simpleUnitOptions: SimpleUnitOption[] = (initData.unitOptions || []).map((u) => ({
+        label: u.label,
+        value: u.value,
+      }));
+      console.log('[useFormStructure] Processed unitOptions:', simpleUnitOptions.length, 'items');
+      setUnitOptions(simpleUnitOptions);
+
+      // 2. 품목 유형에 해당하는 페이지 찾기
+      const page = initData.pages.find((p) => p.item_type === itemType);
+
+      if (!page) {
+        // 페이지가 없으면 빈 구조 반환 (품목기준관리에서 아직 설정 안된 경우)
+        setStructure({
+          page: {
+            id: 0,
+            tenant_id: 0,
+            page_name: `${itemType} 기본 페이지`,
+            item_type: itemType,
+            description: null,
+            absolute_path: null,
+            is_active: true,
+            order_no: 0,
+            created_by: null,
+            updated_by: null,
+            created_at: '',
+            updated_at: '',
+          },
+          sections: [],
+          directFields: [],
+        });
+        return;
       }
 
-      // 캐시에 저장
-      setToCache(cacheKey, data);
+      // 3. 페이지 전체 구조 로드
+      const pageStructure = await itemMasterApi.pages.getStructure(page.id);
+      const formStructure = convertToFormStructure(pageStructure);
 
-      setFormStructure(data);
-      setError(null);
+      setStructure(formStructure);
     } catch (err) {
-      setError(err instanceof Error ? err : new Error('Unknown error'));
+      console.error('품목 폼 구조 로드 실패:', err);
+      setError(err instanceof Error ? err.message : '폼 구조를 불러올 수 없습니다.');
     } finally {
       setIsLoading(false);
     }
-  }, [itemType, partType, cacheKey, useMock]);
+  }, [itemType]);
 
-  /**
-   * 강제 새로고침
-   */
-  const refetch = useCallback(async () => {
-    // 캐시 무효화
-    formStructureCache.delete(cacheKey);
-    await loadFormStructure();
-  }, [cacheKey, loadFormStructure]);
-
-  // 마운트 시 및 의존성 변경 시 로드
   useEffect(() => {
-    if (enabled) {
-      loadFormStructure();
-    }
-
-    return () => {
-      // 언마운트 시 요청 취소
-      if (abortControllerRef.current) {
-        abortControllerRef.current.abort();
-      }
-    };
-  }, [enabled, loadFormStructure]);
+    loadStructure();
+  }, [loadStructure]);
 
   return {
-    formStructure,
+    structure,
     isLoading,
     error,
-    refetch,
+    unitOptions,
+    refetch: loadStructure,
   };
 }
-
-// ===== 캐시 유틸리티 =====
-
-/**
- * 폼 구조 캐시 초기화
- */
-export function clearFormStructureCache(): void {
-  formStructureCache.clear();
-}
-
-/**
- * 특정 품목 유형의 캐시 무효화
- */
-export function invalidateFormStructureCache(itemType: ItemType, partType?: PartType): void {
-  const key = getCacheKey(itemType, partType);
-  formStructureCache.delete(key);
-}
-
-export default useFormStructure;
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/index.tsx b/src/components/items/DynamicItemForm/index.tsx
index 3a854b91..31ff23cb 100644
--- a/src/components/items/DynamicItemForm/index.tsx
+++ b/src/components/items/DynamicItemForm/index.tsx
@@ -1,208 +1,1443 @@
 /**
- * DynamicItemForm Component
+ * DynamicItemForm - 품목기준관리 API 기반 동적 품목 등록 폼
  *
- * 품목기준관리 설정에 따라 동적으로 폼을 렌더링하는 메인 컴포넌트
- *
- * 특징:
- * - API에서 폼 구조 로드 (품목 유형별)
- * - 조건부 섹션/필드 표시
- * - 동적 유효성 검증
- * - 기존 특수 컴포넌트 (BOM, 전개도) 통합 가능
- *
- * @example
- * // 신규 등록
- * <DynamicItemForm
- *   itemType="FG"
- *   onSubmit={handleCreate}
- *   onCancel={handleCancel}
- * />
- *
- * @example
- * // 수정
- * <DynamicItemForm
- *   itemType="PT"
- *   partType="BENDING"
- *   initialValues={existingItem}
- *   onSubmit={handleUpdate}
- *   onCancel={handleCancel}
- * />
+ * 기존 ItemForm과 100% 동일한 디자인 유지
  */
 
 'use client';
 
-import { useEffect } from 'react';
-import { Loader2 } from 'lucide-react';
+import { useState, useEffect, useMemo, useRef } from 'react';
+import { useRouter } from 'next/navigation';
+import { Package, Save, X } from 'lucide-react';
+import { cn } from '@/lib/utils';
+import { Label } from '@/components/ui/label';
+import { Input } from '@/components/ui/input';
+import { PageLoadingSpinner } from '@/components/ui/loading-spinner';
 import { Button } from '@/components/ui/button';
 import { Alert, AlertDescription } from '@/components/ui/alert';
-import { DynamicFormRenderer } from './DynamicFormRenderer';
-import { useFormStructure, useDynamicFormState } from './hooks';
-import type { ItemType, PartType } from '@/types/item';
-import type { FormData } from './types';
+import {
+  Card,
+  CardContent,
+  CardHeader,
+  CardTitle,
+} from '@/components/ui/card';
+import ItemTypeSelect from '../ItemTypeSelect';
+import BendingDiagramSection from '../ItemForm/BendingDiagramSection';
+import { DrawingCanvas } from '../DrawingCanvas';
+import { useFormStructure, useDynamicFormState, useConditionalDisplay } from './hooks';
+import { DynamicFieldRenderer } from './fields';
+import { DynamicBOMSection } from './sections';
+import {
+  generateItemCode,
+  generateAssemblyItemNameSimple,
+  generateAssemblySpecification,
+  generateBendingItemCodeSimple,
+} from './utils/itemCodeGenerator';
+import type { DynamicItemFormProps, DynamicFormData, DynamicSection, DynamicFieldValue, BOMLine, BOMSearchState } from './types';
+import type { ItemType, BendingDetail } from '@/types/item';
+import type { ItemFieldResponse } from '@/types/item-master-api';
 
-interface DynamicItemFormProps {
-  /** 품목 유형 */
-  itemType: ItemType;
-  /** 부품 유형 (PT인 경우) */
-  partType?: PartType;
-  /** 초기 값 (수정 모드) */
-  initialValues?: FormData;
-  /** 제출 핸들러 */
-  onSubmit: (data: FormData) => Promise<void>;
-  /** 취소 핸들러 */
-  onCancel?: () => void;
-  /** 폼 비활성화 */
-  disabled?: boolean;
-  /** Mock 데이터 사용 (API 미구현 시) */
-  useMock?: boolean;
+/**
+ * 헤더 컴포넌트 - 기존 FormHeader와 동일한 디자인
+ */
+function FormHeader({
+  mode,
+  selectedItemType,
+  isSubmitting,
+  onCancel,
+}: {
+  mode: 'create' | 'edit';
+  selectedItemType: string;
+  isSubmitting: boolean;
+  onCancel: () => void;
+}) {
+  return (
+    <div className="flex flex-col md:flex-row md:items-center justify-between gap-4">
+      <div className="flex items-start gap-3">
+        <div className="p-2 bg-primary/10 rounded-lg hidden md:block">
+          <Package className="w-6 h-6 text-primary" />
+        </div>
+        <div>
+          <h1 className="text-xl md:text-2xl">
+            {mode === 'create' ? '품목 등록' : '품목 수정'}
+          </h1>
+          <p className="text-sm text-muted-foreground mt-1">
+            품목 정보를 입력하세요
+          </p>
+        </div>
+      </div>
+
+      <div className="flex gap-1 sm:gap-2">
+        <Button
+          type="button"
+          variant="outline"
+          size="sm"
+          onClick={onCancel}
+          className="gap-1 sm:gap-2"
+          disabled={isSubmitting}
+        >
+          <X className="h-4 w-4" />
+          <span className="hidden sm:inline">취소</span>
+        </Button>
+        <Button
+          type="submit"
+          size="sm"
+          disabled={!selectedItemType || isSubmitting}
+          className="gap-1 sm:gap-2"
+        >
+          <Save className="h-4 w-4" />
+          <span className="hidden sm:inline">{isSubmitting ? '저장 중...' : '저장'}</span>
+        </Button>
+      </div>
+    </div>
+  );
 }
 
-export function DynamicItemForm({
-  itemType,
-  partType,
-  initialValues,
+/**
+ * 밸리데이션 에러 Alert - 기존 ValidationAlert와 동일한 디자인
+ */
+function ValidationAlert({ errors }: { errors: Record<string, string> }) {
+  const errorCount = Object.keys(errors).length;
+
+  if (errorCount === 0) {
+    return null;
+  }
+
+  return (
+    <Alert className="bg-red-50 border-red-200">
+      <AlertDescription className="text-red-900">
+        <div className="flex items-start gap-2">
+          <span className="text-lg">⚠️</span>
+          <div className="flex-1">
+            <strong className="block mb-2">
+              입력 내용을 확인해주세요 ({errorCount}개 오류)
+            </strong>
+            <ul className="space-y-1 text-sm">
+              {Object.entries(errors).map(([fieldKey, errorMessage]) => (
+                <li key={fieldKey} className="flex items-start gap-1">
+                  <span>•</span>
+                  <span>{errorMessage}</span>
+                </li>
+              ))}
+            </ul>
+          </div>
+        </div>
+      </AlertDescription>
+    </Alert>
+  );
+}
+
+/**
+ * 동적 섹션 렌더러
+ */
+function DynamicSectionRenderer({
+  section,
+  formData,
+  errors,
+  onChange,
+  disabled,
+  unitOptions,
+  autoGeneratedItemCode,
+  shouldShowField,
+}: {
+  section: DynamicSection;
+  formData: DynamicFormData;
+  errors: Record<string, string>;
+  onChange: (fieldKey: string, value: DynamicFieldValue) => void;
+  disabled?: boolean;
+  unitOptions: { label: string; value: string }[];
+  autoGeneratedItemCode?: string;
+  shouldShowField?: (fieldId: number) => boolean;
+}) {
+  // 필드를 order_no 기준 정렬
+  const sortedFields = [...section.fields].sort((a, b) => a.orderNo - b.orderNo);
+
+  // 이 섹션에 item_name과 specification 필드가 둘 다 있는지 체크
+  // field_key가 "{id}_item_name" 형식으로 올 수 있어서 includes로 체크
+  const fieldKeys = sortedFields.map((f) => f.field.field_key || `field_${f.field.id}`);
+  const hasItemName = fieldKeys.some((k) => k.includes('item_name'));
+  const hasSpecification = fieldKeys.some((k) => k.includes('specification'));
+  const shouldShowItemCode = hasItemName && hasSpecification && autoGeneratedItemCode !== undefined;
+
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle>{section.section.title}</CardTitle>
+        {section.section.description && (
+          <p className="text-sm text-muted-foreground">
+            {section.section.description}
+          </p>
+        )}
+      </CardHeader>
+      <CardContent className="space-y-4">
+        {sortedFields.map((dynamicField) => {
+          const field = dynamicField.field;
+          const fieldKey = field.field_key || `field_${field.id}`;
+
+          // 필드 조건부 표시 체크
+          if (shouldShowField && !shouldShowField(field.id)) {
+            return null;
+          }
+
+          return (
+            <DynamicFieldRenderer
+              key={field.id}
+              field={field}
+              value={formData[fieldKey]}
+              onChange={(value) => onChange(fieldKey, value)}
+              error={errors[fieldKey]}
+              disabled={disabled}
+              unitOptions={unitOptions}
+            />
+          );
+        })}
+
+        {/* 품목코드 자동생성 필드 (item_name + specification 있는 섹션에만 표시) */}
+        {shouldShowItemCode && (
+          <div>
+            <Label htmlFor="item_code_auto">품목코드 (자동생성)</Label>
+            <Input
+              id="item_code_auto"
+              value={autoGeneratedItemCode || ''}
+              placeholder="품목명과 규격이 입력되면 자동으로 생성됩니다"
+              disabled
+              className="bg-muted text-muted-foreground"
+            />
+            <p className="text-xs text-muted-foreground mt-1">
+              * 품목코드는 &apos;품목명-규격&apos; 형식으로 자동 생성됩니다
+            </p>
+          </div>
+        )}
+      </CardContent>
+    </Card>
+  );
+}
+
+/**
+ * 메인 DynamicItemForm 컴포넌트
+ */
+export default function DynamicItemForm({
+  mode,
+  itemType: initialItemType,
+  initialData,
   onSubmit,
-  onCancel,
-  disabled = false,
-  useMock = true, // 기본적으로 Mock 사용 (API 구현 후 false로 변경)
 }: DynamicItemFormProps) {
-  // 폼 구조 로드
-  const {
-    formStructure,
-    isLoading: isLoadingStructure,
-    error: structureError,
-    refetch: refetchStructure,
-  } = useFormStructure({
-    itemType,
-    partType,
-    useMock,
-  });
+  const router = useRouter();
+
+  // 품목 유형 상태 (변경 가능)
+  const [selectedItemType, setSelectedItemType] = useState<ItemType | ''>(initialItemType || '');
+
+  // 폼 구조 로드 (품목 유형에 따라)
+  const { structure, isLoading, error: structureError, unitOptions } = useFormStructure(
+    selectedItemType as 'FG' | 'PT' | 'SM' | 'RM' | 'CS'
+  );
 
   // 폼 상태 관리
   const {
-    state,
-    setValue,
-    setTouched,
-    validate,
-    reset,
+    formData,
+    errors,
+    isSubmitting,
+    setFieldValue,
+    validateAll,
     handleSubmit,
-  } = useDynamicFormState({
-    sections: formStructure?.sections || [],
-    initialValues,
-  });
+    resetForm,
+  } = useDynamicFormState(initialData);
 
-  // 폼 구조가 변경되면 값 초기화
+  // BOM 상태 관리
+  const [bomLines, setBomLines] = useState<BOMLine[]>([]);
+  const [bomSearchStates, setBomSearchStates] = useState<Record<string, BOMSearchState>>({});
+
+  // 절곡품 전개도 상태 관리 (PT - 절곡 부품 전용)
+  const [bendingDiagramInputMethod, setBendingDiagramInputMethod] = useState<'file' | 'drawing'>('file');
+  const [bendingDiagram, setBendingDiagram] = useState<string>('');
+  const [bendingDiagramFile, setBendingDiagramFile] = useState<File | null>(null);
+  const [isDrawingOpen, setIsDrawingOpen] = useState(false);
+  const [bendingDetails, setBendingDetails] = useState<BendingDetail[]>([]);
+  const [widthSum, setWidthSum] = useState<string>('');
+
+  // 조건부 표시 관리
+  const { shouldShowSection, shouldShowField } = useConditionalDisplay(structure, formData);
+
+  // PT(부품) 품목코드 자동생성용 - 기존 품목코드 목록
+  const [existingItemCodes, setExistingItemCodes] = useState<string[]>([]);
+
+  // PT(부품) 선택 시 기존 품목코드 목록 조회
   useEffect(() => {
-    if (formStructure) {
-      reset(initialValues);
+    if (selectedItemType === 'PT') {
+      // PT 품목 목록 조회하여 기존 코드 수집
+      const fetchExistingCodes = async () => {
+        try {
+          const response = await fetch('/api/proxy/items?type=PT&size=1000');
+          const result = await response.json();
+          if (result.success && result.data?.data) {
+            const codes = result.data.data
+              .map((item: { code?: string; item_code?: string }) => item.code || item.item_code || '')
+              .filter((code: string) => code);
+            setExistingItemCodes(codes);
+            console.log('[DynamicItemForm] PT 기존 품목코드 로드:', codes.length, '개');
+          }
+        } catch (err) {
+          console.error('[DynamicItemForm] PT 품목코드 조회 실패:', err);
+          setExistingItemCodes([]);
+        }
+      };
+      fetchExistingCodes();
+    } else {
+      setExistingItemCodes([]);
     }
-  }, [formStructure, initialValues, reset]);
+  }, [selectedItemType]);
+
+  // 품목 유형 변경 시 폼 초기화
+  useEffect(() => {
+    if (selectedItemType && mode === 'create' && structure) {
+      // 기본값 설정
+      const defaults: DynamicFormData = {
+        item_type: selectedItemType,
+      };
+
+      // 구조에서 기본값 추출
+      structure.sections.forEach((section) => {
+        section.fields.forEach((f) => {
+          const field = f.field;
+          const fieldKey = field.field_key || `field_${field.id}`;
+          if (field.default_value !== null && field.default_value !== undefined) {
+            defaults[fieldKey] = field.default_value;
+          }
+        });
+      });
+
+      structure.directFields.forEach((f) => {
+        const field = f.field;
+        const fieldKey = field.field_key || `field_${field.id}`;
+        if (field.default_value !== null && field.default_value !== undefined) {
+          defaults[fieldKey] = field.default_value;
+        }
+      });
+
+      resetForm(defaults);
+
+      // BOM 상태 초기화 - 빈 상태로 시작 (사용자가 추가 버튼으로 행 추가)
+      setBomLines([]);
+      setBomSearchStates({});
+    }
+  }, [selectedItemType, structure, mode, resetForm]);
+
+  // 모든 필드 목록 (밸리데이션용) - 숨겨진 섹션/필드 제외
+  const allFields = useMemo<ItemFieldResponse[]>(() => {
+    if (!structure) return [];
+
+    const fields: ItemFieldResponse[] = [];
+
+    // 표시되는 섹션의 표시되는 필드만 포함
+    structure.sections.forEach((section) => {
+      // 섹션이 숨겨져 있으면 스킵 (조건부 표시)
+      if (!shouldShowSection(section.section.id)) return;
+
+      section.fields.forEach((f) => {
+        // 필드가 숨겨져 있으면 스킵 (조건부 표시)
+        if (!shouldShowField(f.field.id)) return;
+        fields.push(f.field);
+      });
+    });
+
+    // 직접 필드도 필터링 (조건부 표시)
+    structure.directFields.forEach((f) => {
+      if (!shouldShowField(f.field.id)) return;
+      fields.push(f.field);
+    });
+
+    return fields;
+  }, [structure, shouldShowSection, shouldShowField]);
+
+  // 품목코드 자동생성 관련 필드 정보
+  // field_key 또는 field_name 기준으로 품목명/규격 필드 탐지
+  // 2025-12-03: 연동 드롭다운 로직 제거 - 조건부 섹션 표시로 대체
+  const { hasAutoItemCode, itemNameKey, allSpecificationKeys, statusFieldKey } = useMemo(() => {
+    if (!structure) return { hasAutoItemCode: false, itemNameKey: '', allSpecificationKeys: [] as string[], statusFieldKey: '' };
+
+    let foundItemNameKey = '';
+    let foundStatusFieldKey = '';
+    const specificationKeys: string[] = []; // 모든 규격 필드 키 수집
+
+    const checkField = (fieldKey: string, field: ItemFieldResponse) => {
+      const fieldName = field.field_name || '';
+
+      // 품목명 필드 탐지 (field_key 또는 field_name 기준)
+      const isItemName = fieldKey.includes('item_name') || fieldName.includes('품목명');
+      if (isItemName && !foundItemNameKey) {
+        foundItemNameKey = fieldKey;
+      }
+
+      // 규격 필드 탐지
+      // specification, standard, 규격, 사양 모두 지원
+      const isSpecification = fieldKey.includes('specification') || fieldKey.includes('standard') ||
+                             fieldKey.includes('규격') || fieldName.includes('규격') || fieldName.includes('사양');
+      if (isSpecification) {
+        specificationKeys.push(fieldKey);
+      }
+
+      // 품목 상태 필드 탐지 (is_active, status, 품목상태, 품목 상태)
+      const isStatusField = fieldKey.includes('is_active') || fieldKey.includes('status') ||
+                           fieldKey.includes('active') || fieldName.includes('품목상태') ||
+                           fieldName.includes('품목 상태') || fieldName === '상태';
+      if (isStatusField && !foundStatusFieldKey) {
+        foundStatusFieldKey = fieldKey;
+      }
+    };
+
+    structure.sections.forEach((section) => {
+      section.fields.forEach((f) => {
+        const key = f.field.field_key || `field_${f.field.id}`;
+        checkField(key, f.field);
+      });
+    });
+
+    structure.directFields.forEach((f) => {
+      const key = f.field.field_key || `field_${f.field.id}`;
+      checkField(key, f.field);
+    });
+
+    return {
+      // PT(부품)도 품목코드 자동생성 포함
+      hasAutoItemCode: !!foundItemNameKey,
+      itemNameKey: foundItemNameKey,
+      allSpecificationKeys: specificationKeys,
+      statusFieldKey: foundStatusFieldKey,
+    };
+  }, [structure]);
+
+  // 현재 표시 중인 규격 필드 키 (조건부 표시 고려)
+  // 2025-12-03: 조건부 표시로 숨겨진 필드는 제외하고, 실제 표시되는 규격 필드만 선택
+  const activeSpecificationKey = useMemo(() => {
+    if (!structure || allSpecificationKeys.length === 0) return '';
+
+    // 모든 규격 필드 중 현재 표시 중인 첫 번째 필드 찾기
+    for (const section of structure.sections) {
+      // 섹션이 숨겨져 있으면 스킵
+      if (!shouldShowSection(section.section.id)) continue;
+
+      for (const f of section.fields) {
+        const fieldKey = f.field.field_key || `field_${f.field.id}`;
+        // 필드가 숨겨져 있으면 스킵
+        if (!shouldShowField(f.field.id)) continue;
+        // 규격 필드인지 확인
+        if (allSpecificationKeys.includes(fieldKey)) {
+          return fieldKey;
+        }
+      }
+    }
+
+    // 직접 필드에서도 찾기
+    for (const f of structure.directFields) {
+      const fieldKey = f.field.field_key || `field_${f.field.id}`;
+      if (!shouldShowField(f.field.id)) continue;
+      if (allSpecificationKeys.includes(fieldKey)) {
+        return fieldKey;
+      }
+    }
+
+    // 표시 중인 규격 필드가 없으면 첫 번째 규격 필드 반환 (fallback)
+    return allSpecificationKeys[0] || '';
+  }, [structure, allSpecificationKeys, shouldShowSection, shouldShowField]);
+
+  // 부품 유형 필드 탐지 (PT 품목에서 절곡/조립 부품 판별용)
+  const { partTypeFieldKey, selectedPartType, isBendingPart, isAssemblyPart } = useMemo(() => {
+    if (!structure || selectedItemType !== 'PT') {
+      return { partTypeFieldKey: '', selectedPartType: '', isBendingPart: false, isAssemblyPart: false };
+    }
+
+    let foundPartTypeKey = '';
+
+    // 모든 필드에서 부품 유형 필드 찾기
+    const checkField = (fieldKey: string, field: ItemFieldResponse) => {
+      const fieldName = field.field_name || '';
+      // part_type, 부품유형, 부품 유형 등 탐지
+      const isPartType = fieldKey.includes('part_type') ||
+                        fieldName.includes('부품유형') ||
+                        fieldName.includes('부품 유형');
+      if (isPartType && !foundPartTypeKey) {
+        foundPartTypeKey = fieldKey;
+      }
+    };
+
+    structure.sections.forEach((section) => {
+      section.fields.forEach((f) => {
+        const key = f.field.field_key || `field_${f.field.id}`;
+        checkField(key, f.field);
+      });
+    });
+
+    structure.directFields.forEach((f) => {
+      const key = f.field.field_key || `field_${f.field.id}`;
+      checkField(key, f.field);
+    });
+
+    const currentPartType = (formData[foundPartTypeKey] as string) || '';
+    // "절곡 부품", "BENDING", "절곡부품" 등 다양한 형태 지원
+    const isBending = currentPartType.includes('절곡') || currentPartType.toUpperCase() === 'BENDING';
+    // "조립 부품", "ASSEMBLY", "조립부품" 등 다양한 형태 지원
+    const isAssembly = currentPartType.includes('조립') || currentPartType.toUpperCase() === 'ASSEMBLY';
+
+    console.log('[DynamicItemForm] 부품 유형 감지:', {
+      partTypeFieldKey: foundPartTypeKey,
+      currentPartType,
+      isBending,
+      isAssembly,
+    });
+
+    return {
+      partTypeFieldKey: foundPartTypeKey,
+      selectedPartType: currentPartType,
+      isBendingPart: isBending,
+      isAssemblyPart: isAssembly,
+    };
+  }, [structure, selectedItemType, formData]);
+
+  // 이전 부품 유형 값 추적 (부품 유형 변경 감지용)
+  const prevPartTypeRef = useRef<string>('');
+
+  // 부품 유형 변경 시 조건부 표시 관련 필드 초기화
+  // 2025-12-04: 절곡 ↔ 조립 부품 전환 시 formData 값이 유지되어
+  // 조건부 표시가 잘못 트리거되는 버그 수정
+  // 2025-12-04: setTimeout으로 초기화를 다음 틱으로 미뤄서 Select 두 번 클릭 문제 해결
+  useEffect(() => {
+    if (selectedItemType !== 'PT' || !partTypeFieldKey) return;
+
+    const currentPartType = selectedPartType;
+    const prevPartType = prevPartTypeRef.current;
+
+    // 이전 값이 있고, 현재 값과 다른 경우에만 초기화
+    if (prevPartType && prevPartType !== currentPartType) {
+      console.log('[DynamicItemForm] 부품 유형 변경 감지:', prevPartType, '→', currentPartType);
+
+      // setTimeout으로 다음 틱에서 초기화 실행
+      // → 부품 유형 Select 값 변경이 먼저 완료된 후 초기화
+      setTimeout(() => {
+        // 조건부 표시 대상이 될 수 있는 필드들 수집 및 초기화
+        // (품목명, 재질, 종류, 폭 합계, 모양&길이 등)
+        const fieldsToReset: string[] = [];
+
+        // structure에서 조건부 표시 설정이 있는 필드들 찾기
+        if (structure) {
+          structure.sections.forEach((section) => {
+            section.fields.forEach((f) => {
+              const field = f.field;
+              const fieldKey = field.field_key || `field_${field.id}`;
+              const fieldName = field.field_name || '';
+
+              // 부품 유형 필드는 초기화에서 제외
+              if (fieldKey === partTypeFieldKey) return;
+
+              // 조건부 표시 트리거 필드 (display_condition이 있는 필드)
+              if (field.display_condition) {
+                fieldsToReset.push(fieldKey);
+              }
+
+              // 조건부 표시 대상 필드 (재질, 종류, 폭 합계, 모양&길이 등)
+              const isBendingRelated =
+                fieldName.includes('재질') || fieldName.includes('종류') ||
+                fieldName.includes('폭') || fieldName.includes('모양') ||
+                fieldName.includes('길이') || fieldKey.includes('material') ||
+                fieldKey.includes('category') || fieldKey.includes('width') ||
+                fieldKey.includes('shape') || fieldKey.includes('length');
+
+              if (isBendingRelated) {
+                fieldsToReset.push(fieldKey);
+              }
+            });
+          });
+
+          // 품목명 필드도 초기화 (조건부 표시 트리거 역할)
+          if (itemNameKey) {
+            fieldsToReset.push(itemNameKey);
+          }
+        }
+
+        // 중복 제거 후 초기화
+        const uniqueFields = [...new Set(fieldsToReset)];
+        console.log('[DynamicItemForm] 초기화할 필드:', uniqueFields);
+
+        uniqueFields.forEach((fieldKey) => {
+          setFieldValue(fieldKey, '');
+        });
+      }, 0);
+    }
+
+    // 현재 값을 이전 값으로 저장
+    prevPartTypeRef.current = currentPartType;
+  }, [selectedItemType, partTypeFieldKey, selectedPartType, structure, itemNameKey, setFieldValue]);
+
+  // 절곡부품 전용 필드 탐지 (재질, 종류, 폭 합계, 모양&길이)
+  // 2025-12-04: 조건부 표시 고려하여 종류 필드 선택 로직 개선
+  const { bendingFieldKeys, autoBendingItemCode, allCategoryKeysWithIds } = useMemo(() => {
+    if (!structure || selectedItemType !== 'PT' || !isBendingPart) {
+      return {
+        bendingFieldKeys: {
+          material: '',      // 재질
+          category: '',      // 종류
+          widthSum: '',      // 폭 합계
+          shapeLength: '',   // 모양&길이
+          itemName: '',      // 품목명 (절곡부품 코드 생성용)
+        },
+        autoBendingItemCode: '',
+        allCategoryKeysWithIds: [] as Array<{ key: string; id: number }>,
+      };
+    }
+
+    let materialKey = '';
+    const categoryKeysWithIds: Array<{ key: string; id: number }> = [];  // 종류 필드 + ID
+    let widthSumKey = '';
+    let shapeLengthKey = '';
+    let bendingItemNameKey = '';  // 절곡부품용 품목명 키
+
+    const checkField = (fieldKey: string, field: ItemFieldResponse) => {
+      const fieldName = field.field_name || '';
+      const lowerKey = fieldKey.toLowerCase();
+
+      // 절곡부품 품목명 필드 탐지 - bending_parts 우선
+      // 2025-12-04: 조립부품/절곡부품 품목명 필드가 모두 있을 때 절곡부품용 우선 선택
+      const isBendingItemNameField =
+        lowerKey.includes('bending_parts') ||
+        lowerKey.includes('bending_item') ||
+        lowerKey.includes('절곡부품') ||
+        lowerKey.includes('절곡_부품') ||
+        fieldName.includes('절곡부품') ||
+        fieldName.includes('절곡 부품');
+
+      const isGeneralItemNameField =
+        lowerKey.includes('item_name') ||
+        lowerKey.includes('품목명') ||
+        fieldName.includes('품목명') ||
+        fieldName === '품목명';
+
+      // bending_parts는 무조건 우선 (덮어쓰기)
+      if (isBendingItemNameField) {
+        console.log('[checkField] 절곡부품 품목명 필드 발견!', { fieldKey, fieldName });
+        bendingItemNameKey = fieldKey;
+      }
+      // 일반 품목명은 아직 없을 때만
+      else if (isGeneralItemNameField && !bendingItemNameKey) {
+        console.log('[checkField] 일반 품목명 필드 발견!', { fieldKey, fieldName });
+        bendingItemNameKey = fieldKey;
+      }
+
+      // 재질 필드
+      if (lowerKey.includes('material') || lowerKey.includes('재질') ||
+          lowerKey.includes('texture') || fieldName.includes('재질')) {
+        if (!materialKey) materialKey = fieldKey;
+      }
+
+      // 종류 필드 (type_1, type_2, type_3 등 모두 수집) - ID와 함께 저장
+      if ((lowerKey.includes('category') || lowerKey.includes('종류') ||
+          lowerKey.includes('type_') || fieldName === '종류' || fieldName.includes('종류')) &&
+          !lowerKey.includes('item_name') && !lowerKey.includes('item_type') &&
+          !lowerKey.includes('part_type') && !fieldName.includes('품목명')) {
+        categoryKeysWithIds.push({ key: fieldKey, id: field.id });
+      }
+
+      // 폭 합계 필드
+      if (lowerKey.includes('width_sum') || lowerKey.includes('폭합계') ||
+          lowerKey.includes('폭_합계') || lowerKey.includes('width_total') ||
+          fieldName.includes('폭 합계') || fieldName.includes('폭합계')) {
+        if (!widthSumKey) widthSumKey = fieldKey;
+      }
+
+      // 모양&길이 필드
+      if (lowerKey.includes('shape_length') || lowerKey.includes('모양') ||
+          fieldName.includes('모양') || fieldName.includes('길이')) {
+        if (!shapeLengthKey) shapeLengthKey = fieldKey;
+      }
+    };
+
+    // 모든 필드 검사
+    structure.sections.forEach((section) => {
+      section.fields.forEach((f) => {
+        const key = f.field.field_key || `field_${f.field.id}`;
+        checkField(key, f.field);
+      });
+    });
+
+    structure.directFields.forEach((f) => {
+      const key = f.field.field_key || `field_${f.field.id}`;
+      checkField(key, f.field);
+    });
+
+    // 품목코드 자동생성 (품목명 + 종류 + 모양&길이)
+    // itemNameKey 또는 직접 탐지한 bendingItemNameKey 사용
+    const effectiveItemNameKey = bendingItemNameKey || itemNameKey;
+    const itemNameValue = effectiveItemNameKey ? (formData[effectiveItemNameKey] as string) || '' : '';
+
+    // 2025-12-04: 종류 필드 선택 - 조건부 표시로 현재 보이는 필드만 검사
+    // shouldShowField를 직접 호출할 수 없으므로, 값이 있는 필드 중 마지막 것을 선택
+    // (품목명 변경 시 이전 종류는 초기화되므로, 현재 표시되는 종류만 값이 있음)
+    let activeCategoryKey = '';
+    let categoryValue = '';
+    for (const { key: catKey, id: catId } of categoryKeysWithIds) {
+      const val = (formData[catKey] as string) || '';
+      if (val) {
+        // 마지막으로 선택된 종류 필드를 사용 (최신 값)
+        activeCategoryKey = catKey;
+        categoryValue = val;
+        // break 제거 - 마지막 값이 있는 필드 사용
+      }
+    }
+
+    const shapeLengthValue = shapeLengthKey ? (formData[shapeLengthKey] as string) || '' : '';
+
+    const autoCode = generateBendingItemCodeSimple(itemNameValue, categoryValue, shapeLengthValue);
+
+    console.log('[DynamicItemForm] 절곡부품 필드 탐지:', {
+      bendingItemNameKey,
+      itemNameKey,
+      effectiveItemNameKey,
+      materialKey,
+      categoryKeysWithIds,
+      activeCategoryKey,
+      widthSumKey,
+      shapeLengthKey,
+      formDataKeys: Object.keys(formData),
+      values: { itemNameValue, categoryValue, shapeLengthValue },
+      autoCode,
+    });
+
+    return {
+      bendingFieldKeys: {
+        material: materialKey,
+        category: activeCategoryKey,  // 현재 활성화된 종류 필드
+        widthSum: widthSumKey,
+        shapeLength: shapeLengthKey,
+        itemName: effectiveItemNameKey,
+      },
+      autoBendingItemCode: autoCode,
+      allCategoryKeysWithIds: categoryKeysWithIds,  // 모든 종류 필드 키+ID (초기화용)
+    };
+  }, [structure, selectedItemType, isBendingPart, formData, itemNameKey]);
+
+  // 2025-12-04: 품목명 변경 시 종류 필드 값 초기화
+  // 품목명(A)→종류(A1) 선택 후 품목명(B)로 변경 시, 이전 종류(A1) 값이 남아있어서
+  // 새 종류(B1) 선택해도 이전 값이 품목코드에 적용되는 버그 수정
+  const prevItemNameValueRef = useRef<string>('');
+
+  useEffect(() => {
+    if (!isBendingPart || !bendingFieldKeys.itemName) return;
+
+    const currentItemNameValue = (formData[bendingFieldKeys.itemName] as string) || '';
+    const prevItemNameValue = prevItemNameValueRef.current;
+
+    // 품목명이 변경되었고, 이전 값이 있었을 때만 종류 필드 초기화
+    if (prevItemNameValue && prevItemNameValue !== currentItemNameValue) {
+      console.log('[DynamicItemForm] 품목명 변경 감지:', prevItemNameValue, '→', currentItemNameValue);
+
+      // 모든 종류 필드 값 초기화
+      allCategoryKeysWithIds.forEach(({ key }) => {
+        const currentVal = (formData[key] as string) || '';
+        if (currentVal) {
+          console.log('[DynamicItemForm] 종류 필드 초기화:', key);
+          setFieldValue(key, '');
+        }
+      });
+    }
+
+    // 현재 값을 이전 값으로 저장
+    prevItemNameValueRef.current = currentItemNameValue;
+  }, [isBendingPart, bendingFieldKeys.itemName, formData, allCategoryKeysWithIds, setFieldValue]);
+
+  // BOM 필요 체크박스 필드 키 탐지 (structure에서 직접 검색)
+  const bomRequiredFieldKey = useMemo(() => {
+    if (!structure) return '';
+
+    // 모든 섹션의 필드에서 BOM 관련 체크박스 필드 찾기
+    for (const section of structure.sections) {
+      for (const f of section.fields) {
+        const field = f.field;
+        const fieldKey = field.field_key || '';
+        const fieldName = field.field_name || '';
+        const fieldType = field.field_type || '';
+
+        // 체크박스 타입이고 BOM 관련 필드인지 확인
+        const isCheckbox = fieldType.toLowerCase() === 'checkbox' || fieldType.toLowerCase() === 'boolean';
+        const isBomRelated =
+          fieldKey.toLowerCase().includes('bom') ||
+          fieldName.toLowerCase().includes('bom') ||
+          fieldName.includes('부품구성') ||
+          fieldKey.includes('부품구성');
+
+        if (isCheckbox && isBomRelated) {
+          console.log('[DynamicItemForm] BOM 체크박스 필드 발견:', {
+            fieldKey,
+            fieldName,
+            fieldType,
+            resultKey: field.field_key || `field_${field.id}`,
+          });
+          return field.field_key || `field_${field.id}`;
+        }
+      }
+    }
+
+    // 직접 필드에서도 찾기
+    for (const f of structure.directFields) {
+      const field = f.field;
+      const fieldKey = field.field_key || '';
+      const fieldName = field.field_name || '';
+      const fieldType = field.field_type || '';
+
+      const isCheckbox = fieldType.toLowerCase() === 'checkbox' || fieldType.toLowerCase() === 'boolean';
+      const isBomRelated =
+        fieldKey.toLowerCase().includes('bom') ||
+        fieldName.toLowerCase().includes('bom') ||
+        fieldName.includes('부품구성') ||
+        fieldKey.includes('부품구성');
+
+      if (isCheckbox && isBomRelated) {
+        console.log('[DynamicItemForm] BOM 체크박스 필드 발견 (직접필드):', {
+          fieldKey,
+          fieldName,
+          fieldType,
+          resultKey: field.field_key || `field_${field.id}`,
+        });
+        return field.field_key || `field_${field.id}`;
+      }
+    }
+
+    console.log('[DynamicItemForm] BOM 체크박스 필드를 찾지 못함');
+    return '';
+  }, [structure]);
+
+  // 조립 부품 필드 탐지 (측면규격 가로/세로, 길이) - 자동생성용
+  // 2025-12-03: 필드 탐지 조건 개선 - 더 정확한 매칭
+  const { hasAssemblyFields, assemblyFieldKeys, autoAssemblyItemName, autoAssemblySpec } = useMemo(() => {
+    if (!structure || selectedItemType !== 'PT') {
+      return {
+        hasAssemblyFields: false,
+        assemblyFieldKeys: { sideSpecWidth: '', sideSpecHeight: '', assemblyLength: '' },
+        autoAssemblyItemName: '',
+        autoAssemblySpec: '',
+      };
+    }
+
+    let sideSpecWidthKey = '';
+    let sideSpecHeightKey = '';
+    let assemblyLengthKey = '';
+
+    const checkField = (fieldKey: string, field: ItemFieldResponse) => {
+      const fieldName = field.field_name || '';
+      const lowerKey = fieldKey.toLowerCase();
+
+      // 측면규격 가로 - 더 정확한 조건 (측면 + 가로 조합)
+      const isWidthField = lowerKey.includes('side_spec_width') || lowerKey.includes('sidespecwidth') ||
+          fieldName.includes('측면규격(가로)') || fieldName.includes('측면 규격(가로)') ||
+          fieldName.includes('측면규격 가로') || fieldName.includes('측면 가로') ||
+          (fieldName.includes('측면') && fieldName.includes('가로'));
+      if (isWidthField && !sideSpecWidthKey) {
+        sideSpecWidthKey = fieldKey;
+      }
+
+      // 측면규격 세로 - 더 정확한 조건 (측면 + 세로 조합)
+      const isHeightField = lowerKey.includes('side_spec_height') || lowerKey.includes('sidespecheight') ||
+          fieldName.includes('측면규격(세로)') || fieldName.includes('측면 규격(세로)') ||
+          fieldName.includes('측면규격 세로') || fieldName.includes('측면 세로') ||
+          (fieldName.includes('측면') && fieldName.includes('세로'));
+      if (isHeightField && !sideSpecHeightKey) {
+        sideSpecHeightKey = fieldKey;
+      }
+
+      // 길이 - 조립 부품 길이 필드
+      const isLengthField = lowerKey.includes('assembly_length') || lowerKey.includes('assemblylength') ||
+          lowerKey === 'length' || lowerKey.endsWith('_length') ||
+          fieldName === '길이' || fieldName.includes('조립') && fieldName.includes('길이');
+      if (isLengthField && !assemblyLengthKey) {
+        assemblyLengthKey = fieldKey;
+      }
+    };
+
+    // 모든 필드 검사
+    structure.sections.forEach((section) => {
+      section.fields.forEach((f) => {
+        const key = f.field.field_key || `field_${f.field.id}`;
+        checkField(key, f.field);
+      });
+    });
+
+    structure.directFields.forEach((f) => {
+      const key = f.field.field_key || `field_${f.field.id}`;
+      checkField(key, f.field);
+    });
+
+    // 조립 부품 여부: 측면규격 가로/세로, 길이 필드가 모두 있어야 함
+    const isAssembly = !!(sideSpecWidthKey && sideSpecHeightKey && assemblyLengthKey);
+
+    // 자동생성 값 계산
+    const selectedItemName = itemNameKey ? (formData[itemNameKey] as string) || '' : '';
+    const sideSpecWidth = sideSpecWidthKey ? (formData[sideSpecWidthKey] as string) || '' : '';
+    const sideSpecHeight = sideSpecHeightKey ? (formData[sideSpecHeightKey] as string) || '' : '';
+    const assemblyLength = assemblyLengthKey ? (formData[assemblyLengthKey] as string) || '' : '';
+
+    // 품목명: 선택한 품목명 가로x세로
+    const autoItemName = generateAssemblyItemNameSimple(selectedItemName, sideSpecWidth, sideSpecHeight);
+
+    // 규격: 가로x세로x길이(네자리)
+    const autoSpec = generateAssemblySpecification(sideSpecWidth, sideSpecHeight, assemblyLength);
+
+    console.log('[DynamicItemForm] 조립 부품 필드 탐지:', {
+      isAssembly,
+      sideSpecWidthKey,
+      sideSpecHeightKey,
+      assemblyLengthKey,
+      values: { sideSpecWidth, sideSpecHeight, assemblyLength },
+      autoItemName,
+      autoSpec,
+    });
+
+    return {
+      hasAssemblyFields: isAssembly,
+      assemblyFieldKeys: {
+        sideSpecWidth: sideSpecWidthKey,
+        sideSpecHeight: sideSpecHeightKey,
+        assemblyLength: assemblyLengthKey,
+      },
+      autoAssemblyItemName: autoItemName,
+      autoAssemblySpec: autoSpec,
+    };
+  }, [structure, selectedItemType, formData, itemNameKey]);
+
+  // 품목코드 자동생성 값
+  // PT(부품): 영문약어-순번 (예: GR-001, MOTOR-002)
+  // 기타 품목: 품목명-규격 (기존 방식)
+  // 2025-12-03: 연동 드롭다운 로직 제거 - 단순화
+  // 2025-12-03: activeSpecificationKey 사용하여 조건부 표시 고려
+  const autoGeneratedItemCode = useMemo(() => {
+    if (!hasAutoItemCode) return '';
+
+    // field_key가 "{id}_item_name" 형식일 수 있어서 동적으로 키 사용
+    const itemName = (formData[itemNameKey] as string) || '';
+    // 현재 표시 중인 규격 필드 값 사용 (조건부 표시 고려)
+    const specification = activeSpecificationKey ? (formData[activeSpecificationKey] as string) || '' : '';
+
+    if (!itemName) return '';
+
+    // PT(부품)인 경우: 영문약어-순번 형식 사용
+    if (selectedItemType === 'PT') {
+      // generateItemCode는 품목명을 기반으로 영문약어를 찾고 순번을 계산
+      const generatedCode = generateItemCode(itemName, existingItemCodes);
+      return generatedCode;
+    }
+
+    // 기타 품목: 기존 방식 (품목명-규격)
+    if (!specification) return itemName;
+    return `${itemName}-${specification}`;
+  }, [hasAutoItemCode, itemNameKey, activeSpecificationKey, formData, selectedItemType, existingItemCodes]);
+
+  // 품목 유형 변경 핸들러
+  const handleItemTypeChange = (type: ItemType) => {
+    setSelectedItemType(type);
+  };
+
+  // 폼 제출 핸들러
+  const handleFormSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+
+    // 밸리데이션 - 조건부 표시로 숨겨진 필드는 이미 allFields에서 제외됨
+    // 2025-12-03: 연동 드롭다운 로직 제거 - 단순화
+    const isValid = validateAll(allFields);
+    if (!isValid) {
+      return;
+    }
+
+    // field_key → 백엔드 필드명 매핑
+    // field_key 형식: "{id}_{key}" (예: "98_item_name", "110_품목명")
+    // 백엔드 필드명으로 변환 필요
+    // 2025-12-03: 한글 field_key 지원 추가
+    const fieldKeyToBackendKey: Record<string, string> = {
+      'item_name': 'name',
+      '품목명': 'name',           // 한글 field_key 지원
+      'specification': 'spec',
+      'standard': 'spec',         // 규격 대체 필드명
+      '규격': 'spec',             // 한글 field_key 지원
+      '사양': 'spec',             // 한글 대체
+      'unit': 'unit',
+      '단위': 'unit',             // 한글 field_key 지원
+      'note': 'note',
+      '비고': 'note',             // 한글 field_key 지원
+      'description': 'description',
+      '설명': 'description',      // 한글 field_key 지원
+      'part_type': 'part_type',
+      '부품유형': 'part_type',    // 한글 field_key 지원
+      '부품 유형': 'part_type',   // 공백 포함 한글
+      'is_active': 'is_active',
+      'status': 'is_active',
+      'active': 'is_active',
+      '품목상태': 'is_active',    // 한글 field_key 지원
+      '품목 상태': 'is_active',   // 공백 포함 한글
+      '상태': 'is_active',        // 짧은 한글
+    };
+
+    // formData를 백엔드 필드명으로 변환
+    const convertedData: Record<string, any> = {};
+    Object.entries(formData).forEach(([key, value]) => {
+      // "{id}_{fieldKey}" 형식에서 fieldKey 추출
+      const underscoreIndex = key.indexOf('_');
+      if (underscoreIndex > 0) {
+        const fieldKey = key.substring(underscoreIndex + 1);
+        const backendKey = fieldKeyToBackendKey[fieldKey] || fieldKey;
+
+        // is_active 필드는 boolean으로 변환
+        if (backendKey === 'is_active') {
+          // "활성", true, "true", "1", 1 등을 true로, 나머지는 false로
+          const isActive = value === true || value === 'true' || value === '1' ||
+                          value === 1 || value === '활성' || value === 'active';
+          convertedData[backendKey] = isActive;
+        } else {
+          convertedData[backendKey] = value;
+        }
+      } else {
+        // 변환 불필요한 필드는 그대로
+        convertedData[key] = value;
+      }
+    });
+
+    // 품목명 값 추출 (품목코드와 품목명 모두 필요)
+    // 2025-12-04: 절곡 부품은 별도 품목명 필드(bendingFieldKeys.itemName) 사용
+    const effectiveItemNameKeyForSubmit = isBendingPart && bendingFieldKeys.itemName
+      ? bendingFieldKeys.itemName
+      : itemNameKey;
+    const itemNameValue = effectiveItemNameKeyForSubmit
+      ? (formData[effectiveItemNameKeyForSubmit] as string) || ''
+      : '';
+
+    // 조립/절곡 부품 자동생성 값 결정
+    // 조립 부품: 품목명 = "품목명 가로x세로", 규격 = "가로x세로x길이"
+    // 절곡 부품: 품목명 = bendingFieldKeys.itemName에서 선택한 값, 규격 = 없음 (품목코드로 대체)
+    let finalName: string;
+    let finalSpec: string | undefined;
+
+    if (isAssemblyPart && autoAssemblyItemName) {
+      // 조립 부품: 자동생성 품목명/규격 사용
+      finalName = autoAssemblyItemName;
+      finalSpec = autoAssemblySpec;
+    } else if (isBendingPart) {
+      // 절곡 부품: bendingFieldKeys.itemName의 값 사용
+      finalName = itemNameValue || convertedData.name || '';
+      finalSpec = convertedData.spec;
+    } else {
+      // 기타: 기존 로직
+      finalName = convertedData.name || itemNameValue;
+      finalSpec = convertedData.spec;
+    }
+
+    console.log('[DynamicItemForm] 품목명/규격 결정:', {
+      isAssemblyPart,
+      autoAssemblyItemName,
+      autoAssemblySpec,
+      convertedDataName: convertedData.name,
+      convertedDataSpec: convertedData.spec,
+      finalName,
+      finalSpec,
+    });
+
+    // 품목코드 결정
+    // 2025-12-04: 절곡 부품은 autoBendingItemCode 사용
+    let finalCode: string;
+    if (isBendingPart && autoBendingItemCode) {
+      finalCode = autoBendingItemCode;
+    } else if (hasAutoItemCode && autoGeneratedItemCode) {
+      finalCode = autoGeneratedItemCode;
+    } else {
+      finalCode = convertedData.code || itemNameValue;
+    }
+
+    // 품목 유형 및 BOM 데이터 추가
+    const submitData: DynamicFormData = {
+      ...convertedData,
+      // 백엔드 필드명 사용
+      product_type: selectedItemType,  // item_type → product_type
+      // 2025-12-03: 조립 부품 자동생성 품목명/규격 사용
+      // 2025-12-04: 절곡 부품도 자동생성 품목코드 사용
+      name: finalName,  // 조립 부품: 품목명 가로x세로, 절곡 부품: 품목명 필드값, 기타: 품목명 필드값
+      spec: finalSpec,  // 조립 부품: 가로x세로x길이, 기타: 규격 필드값
+      code: finalCode,  // 절곡 부품: autoBendingItemCode, 기타: autoGeneratedItemCode
+      // BOM 데이터를 배열로 포함
+      bom: bomLines.map((line) => ({
+        child_item_code: line.childItemCode,
+        child_item_name: line.childItemName,
+        specification: line.specification || '',
+        material: line.material || '',
+        quantity: line.quantity,
+        unit: line.unit,
+        unit_price: line.unitPrice || 0,
+        note: line.note || '',
+      })),
+      // 절곡품 전개도 데이터 (PT - 절곡 부품 전용)
+      ...(selectedItemType === 'PT' && isBendingPart ? {
+        part_type: 'BENDING',
+        bending_diagram: bendingDiagram || null,
+        bending_details: bendingDetails.length > 0 ? bendingDetails : null,
+        width_sum: widthSum || null,
+      } : {}),
+      // 조립품 전개도 데이터 (PT - 조립 부품 전용)
+      ...(selectedItemType === 'PT' && isAssemblyPart ? {
+        part_type: 'ASSEMBLY',
+        bending_diagram: bendingDiagram || null,  // 조립품도 동일한 전개도 필드 사용
+      } : {}),
+    };
+
+    // is_active 디버깅 로그
+    console.log('[DynamicItemForm] is_active 디버깅:', {
+      formDataKeys: Object.keys(formData).filter(k => k.includes('active') || k.includes('상태') || k.includes('status')),
+      convertedIsActive: convertedData.is_active,
+      submitDataIsActive: submitData.is_active,
+      formDataValues: Object.entries(formData).filter(([k]) => k.includes('active') || k.includes('상태') || k.includes('status')),
+    });
+    console.log('[DynamicItemForm] 제출 데이터:', submitData);
+
+    await handleSubmit(async () => {
+      await onSubmit(submitData);
+      router.push('/items');
+      router.refresh();
+    });
+  };
 
   // 로딩 상태
-  if (isLoadingStructure) {
+  if (isLoading && selectedItemType) {
     return (
-      <div className="flex items-center justify-center py-12">
-        <Loader2 className="h-8 w-8 animate-spin text-primary" />
-        <span className="ml-3 text-muted-foreground">폼 구조 로딩 중...</span>
-      </div>
+      <PageLoadingSpinner
+        text="폼 구조를 불러오는 중..."
+        minHeight="min-h-[40vh]"
+      />
     );
   }
 
   // 에러 상태
   if (structureError) {
     return (
-      <Alert variant="destructive">
-        <AlertDescription className="flex items-center justify-between">
-          <span>폼 구조를 불러오는데 실패했습니다: {structureError.message}</span>
-          <Button variant="outline" size="sm" onClick={refetchStructure}>
-            다시 시도
-          </Button>
+      <Alert className="bg-red-50 border-red-200">
+        <AlertDescription className="text-red-900">
+          ⚠️ 폼 구조를 불러오는데 실패했습니다: {structureError}
         </AlertDescription>
       </Alert>
     );
   }
 
-  // 폼 구조가 없는 경우
-  if (!formStructure) {
-    return (
-      <Alert>
-        <AlertDescription>
-          해당 품목 유형({itemType})의 폼 구조가 정의되지 않았습니다.
-          품목기준관리에서 페이지를 먼저 설정해주세요.
-        </AlertDescription>
-      </Alert>
-    );
-  }
+  // 섹션 정렬
+  const sortedSections = structure
+    ? [...structure.sections].sort((a, b) => a.orderNo - b.orderNo)
+    : [];
 
-  // 폼 제출
-  const onFormSubmit = handleSubmit(onSubmit);
+  // 직접 필드 정렬
+  const sortedDirectFields = structure
+    ? [...structure.directFields].sort((a, b) => a.orderNo - b.orderNo)
+    : [];
+
+  // 일반 섹션들 (BOM 제외) - 기본 정보 카드에 통합할 섹션들
+  const normalSections = sortedSections.filter((s) => s.section.type !== 'bom');
+
+  // BOM 섹션 - 별도 카드로 렌더링
+  const bomSection = sortedSections.find((s) => s.section.type === 'bom');
+
+  // 첫 번째 일반 섹션 (기본 필드용)
+  const firstDefaultSection = normalSections[0];
+
+  // 나머지 일반 섹션들 (하위 섹션으로 렌더링)
+  const additionalSections = normalSections.slice(1);
+
+  // 통합 섹션의 필드 정렬
+  const firstSectionFields = firstDefaultSection
+    ? [...firstDefaultSection.fields].sort((a, b) => a.orderNo - b.orderNo)
+    : [];
 
   return (
-    <form onSubmit={onFormSubmit} className="space-y-6">
-      {/* 페이지 정보 (디버그용, 필요시 제거) */}
-      {process.env.NODE_ENV === 'development' && (
-        <div className="text-xs text-muted-foreground bg-gray-50 p-2 rounded">
-          📄 {formStructure.page.page_name} | 품목유형: {formStructure.page.item_type}
-          {formStructure.page.part_type && ` | 부품유형: ${formStructure.page.part_type}`}
-        </div>
-      )}
+    <form onSubmit={handleFormSubmit} className="space-y-6">
+      {/* Validation 에러 Alert */}
+      <ValidationAlert errors={errors} />
 
-      {/* 동적 폼 렌더러 */}
-      <DynamicFormRenderer
-        sections={formStructure.sections}
-        conditionalSections={formStructure.conditionalSections}
-        conditionalFields={formStructure.conditionalFields}
-        values={state.values}
-        errors={state.errors}
-        onChange={(fieldKey, value) => {
-          setValue(fieldKey, value);
-        }}
-        onBlur={(fieldKey) => {
-          setTouched(fieldKey);
-        }}
-        disabled={disabled || state.isSubmitting}
+      {/* 헤더 */}
+      <FormHeader
+        mode={mode}
+        selectedItemType={selectedItemType}
+        isSubmitting={isSubmitting}
+        onCancel={() => router.back()}
       />
 
-      {/* 버튼 영역 */}
-      <div className="flex items-center justify-end gap-3 pt-4 border-t">
-        {onCancel && (
-          <Button
-            type="button"
-            variant="outline"
-            onClick={onCancel}
-            disabled={state.isSubmitting}
-          >
-            취소
-          </Button>
-        )}
-        <Button
-          type="submit"
-          disabled={disabled || state.isSubmitting}
-        >
-          {state.isSubmitting ? (
-            <>
-              <Loader2 className="mr-2 h-4 w-4 animate-spin" />
-              저장 중...
-            </>
-          ) : (
-            '저장'
-          )}
-        </Button>
-      </div>
+      {/* 기본 정보 - 목업과 동일한 레이아웃 (모든 필드 한 줄씩) */}
+      <Card>
+        <CardHeader className="pb-4">
+          <CardTitle className="text-base font-medium">기본 정보</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          {/* 품목 유형 선택 */}
+          <div>
+            <ItemTypeSelect
+              value={selectedItemType}
+              onChange={handleItemTypeChange}
+              disabled={mode === 'edit'}
+              required
+            />
+            <p className="text-xs text-muted-foreground mt-1">
+              * 품목 유형에 따라 입력 항목이 다릅니다
+            </p>
+          </div>
+
+          {/* 직접 필드 (페이지에 직접 연결된 필드) */}
+          {selectedItemType && sortedDirectFields.map((dynamicField) => {
+            const field = dynamicField.field;
+            const fieldKey = field.field_key || `field_${field.id}`;
+
+            // 필드 조건부 표시 체크
+            if (!shouldShowField(field.id)) {
+              return null;
+            }
+
+            return (
+              <DynamicFieldRenderer
+                key={field.id}
+                field={field}
+                value={formData[fieldKey]}
+                onChange={(value) => setFieldValue(fieldKey, value)}
+                error={errors[fieldKey]}
+                disabled={isSubmitting}
+                unitOptions={unitOptions}
+              />
+            );
+          })}
+
+          {/* 첫 번째 섹션의 필드 렌더링 */}
+          {selectedItemType && firstSectionFields.map((dynamicField) => {
+            const field = dynamicField.field;
+            const fieldKey = field.field_key || `field_${field.id}`;
+
+            // 필드 조건부 표시 체크 (백엔드 설정 그대로 유지)
+            if (!shouldShowField(field.id)) {
+              return null;
+            }
+
+            const isSpecField = fieldKey === activeSpecificationKey;
+            const isStatusField = fieldKey === statusFieldKey;
+            // 비고 필드인지 체크 (절곡부품 품목코드 자동생성 위치)
+            const fieldName = field.field_name || '';
+            const isNoteField = fieldKey.includes('note') || fieldKey.includes('비고') ||
+                               fieldName.includes('비고') || fieldName === '비고';
+
+            // 절곡부품 박스 스타일링 (재질, 폭합계, 모양&길이)
+            const isBendingBoxField = isBendingPart && (
+              fieldKey === bendingFieldKeys.material ||
+              fieldKey === bendingFieldKeys.widthSum ||
+              fieldKey === bendingFieldKeys.shapeLength
+            );
+            const isFirstBendingBoxField = isBendingPart && fieldKey === bendingFieldKeys.material;
+            const isLastBendingBoxField = isBendingPart && fieldKey === bendingFieldKeys.shapeLength;
+
+            return (
+              <div
+                key={field.id}
+                className={cn(
+                  isBendingBoxField && 'border-x border-gray-200 px-4 bg-gray-50/30',
+                  isFirstBendingBoxField && 'border-t rounded-t-lg pt-4 mt-4',
+                  isBendingBoxField && !isFirstBendingBoxField && '-mt-4 pt-4',
+                  isLastBendingBoxField && 'border-b rounded-b-lg pb-4'
+                )}
+              >
+                <DynamicFieldRenderer
+                  field={field}
+                  value={formData[fieldKey]}
+                  onChange={(value) => setFieldValue(fieldKey, value)}
+                  error={errors[fieldKey]}
+                  disabled={isSubmitting}
+                  unitOptions={unitOptions}
+                />
+                {/* 규격 필드 바로 다음에 품목코드 자동생성 필드 표시 (절곡부품 제외) */}
+                {isSpecField && hasAutoItemCode && !isBendingPart && (
+                  <div className="mt-4">
+                    <Label htmlFor="item_code_auto">품목코드 (자동생성)</Label>
+                    <Input
+                      id="item_code_auto"
+                      value={autoGeneratedItemCode || ''}
+                      placeholder="품목명과 규격이 입력되면 자동으로 생성됩니다"
+                      disabled
+                      className="bg-muted text-muted-foreground"
+                    />
+                    <p className="text-xs text-muted-foreground mt-1">
+                      {selectedItemType === 'PT'
+                        ? "* 품목코드는 '영문약어-순번' 형식으로 자동 생성됩니다"
+                        : "* 품목코드는 '품목명-규격' 형식으로 자동 생성됩니다"}
+                    </p>
+                  </div>
+                )}
+                {/* 품목 상태 필드 하단 안내 메시지 */}
+                {isStatusField && (
+                  <p className="text-xs text-muted-foreground mt-1">
+                    * 비활성 시 품목 사용이 제한됩니다
+                  </p>
+                )}
+                {/* 비고 필드 다음에 절곡부품 품목코드 자동생성 */}
+                {isNoteField && isBendingPart && (
+                  <div className="mt-4">
+                    <Label htmlFor="bending_item_code_auto">품목코드 (자동생성)</Label>
+                    <Input
+                      id="bending_item_code_auto"
+                      value={autoBendingItemCode || ''}
+                      placeholder="품목명과 종류가 입력되면 자동으로 생성됩니다"
+                      disabled
+                      className="bg-muted text-muted-foreground"
+                    />
+                    <p className="text-xs text-muted-foreground mt-1">
+                      * 절곡 부품 품목코드는 &apos;품목명+종류+길이축약&apos; 형식으로 자동 생성됩니다 (예: RM30)
+                    </p>
+                  </div>
+                )}
+              </div>
+            );
+          })}
+
+          {/* 추가 섹션들 (기본 정보 카드 내에 하위 섹션으로 통합) */}
+          {selectedItemType && additionalSections.map((section) => {
+            // 조건부 표시 체크
+            if (!shouldShowSection(section.section.id)) {
+              return null;
+            }
+
+            // 부품 유형에 따른 섹션 필터링
+            const sectionTitle = section.section.title || '';
+            const isPurchaseSection = sectionTitle.includes('구매 부품');
+            const isAssemblySectionTitle = sectionTitle.includes('조립 부품');
+
+            // 조립 부품 선택 시 구매 부품 섹션 숨김
+            if (isAssemblyPart && isPurchaseSection) {
+              return null;
+            }
+            // 구매 부품 선택 시 조립 부품 섹션 숨김
+            if (!isAssemblyPart && !isBendingPart && isAssemblySectionTitle) {
+              return null;
+            }
+
+            // 섹션 필드 정렬
+            const sectionFields = [...section.fields].sort((a, b) => a.orderNo - b.orderNo);
+
+            return (
+              <div key={section.section.id} className="pt-4 border-t">
+                {/* 하위 섹션 제목 */}
+                <h3 className="text-sm font-medium mb-4">{section.section.title}</h3>
+                {section.section.description && (
+                  <p className="text-xs text-muted-foreground mb-4">
+                    {section.section.description}
+                  </p>
+                )}
+                {/* 하위 섹션 필드들 */}
+                <div className="space-y-4">
+                  {sectionFields.map((dynamicField) => {
+                    const field = dynamicField.field;
+                    const fieldKey = field.field_key || `field_${field.id}`;
+
+                    // 필드 조건부 표시 체크
+                    if (!shouldShowField(field.id)) {
+                      return null;
+                    }
+
+                    return (
+                      <DynamicFieldRenderer
+                        key={field.id}
+                        field={field}
+                        value={formData[fieldKey]}
+                        onChange={(value) => setFieldValue(fieldKey, value)}
+                        error={errors[fieldKey]}
+                        disabled={isSubmitting}
+                        unitOptions={unitOptions}
+                      />
+                    );
+                  })}
+                </div>
+              </div>
+            );
+          })}
+        </CardContent>
+      </Card>
+
+      {/* 품목 유형 선택 안내 경고 */}
+      {!selectedItemType && (
+        <Alert className="bg-orange-50 border-orange-200">
+          <AlertDescription className="text-orange-900">
+            ⚠️ 품목 유형을 먼저 선택해주세요
+          </AlertDescription>
+        </Alert>
+      )}
+
+      {/* 조립품 전개도 섹션 (PT - 조립 부품 전용) - 품목명 선택 시 표시 */}
+      {selectedItemType === 'PT' && isAssemblyPart && (
+        <BendingDiagramSection
+          selectedPartType="ASSEMBLY"
+          bendingDiagramInputMethod={bendingDiagramInputMethod}
+          setBendingDiagramInputMethod={setBendingDiagramInputMethod}
+          bendingDiagram={bendingDiagram}
+          setBendingDiagram={setBendingDiagram}
+          setBendingDiagramFile={setBendingDiagramFile}
+          setIsDrawingOpen={setIsDrawingOpen}
+          bendingDetails={bendingDetails}
+          setBendingDetails={setBendingDetails}
+          setWidthSum={setWidthSum}
+          setValue={(key, value) => setFieldValue(key, value)}
+          isSubmitting={isSubmitting}
+        />
+      )}
+
+      {/* 절곡품 전개도 섹션 (PT - 절곡 부품 전용) */}
+      {selectedItemType === 'PT' && isBendingPart && (
+        <BendingDiagramSection
+          selectedPartType="BENDING"
+          bendingDiagramInputMethod={bendingDiagramInputMethod}
+          setBendingDiagramInputMethod={setBendingDiagramInputMethod}
+          bendingDiagram={bendingDiagram}
+          setBendingDiagram={setBendingDiagram}
+          setBendingDiagramFile={setBendingDiagramFile}
+          setIsDrawingOpen={setIsDrawingOpen}
+          bendingDetails={bendingDetails}
+          setBendingDetails={setBendingDetails}
+          setWidthSum={setWidthSum}
+          setValue={(key, value) => setFieldValue(key, value)}
+          isSubmitting={isSubmitting}
+        />
+      )}
+
+      {/* BOM 섹션 (부품구성 필요 체크 시에만 표시) */}
+      {selectedItemType && bomSection && (() => {
+        // bomRequiredFieldKey는 useMemo에서 structure 기반으로 미리 계산됨
+        const bomValue = bomRequiredFieldKey ? formData[bomRequiredFieldKey] : undefined;
+        const isBomRequired = bomValue === true || bomValue === 'true' || bomValue === '1' || bomValue === 1;
+
+        // 디버깅 로그
+        console.log('[DynamicItemForm] BOM 체크 디버깅:', {
+          bomRequiredFieldKey,
+          bomValue,
+          isBomRequired,
+          formDataKeys: Object.keys(formData),
+        });
+
+        if (!isBomRequired) return null;
+
+        return (
+          <DynamicBOMSection
+            section={bomSection}
+            bomLines={bomLines}
+            setBomLines={setBomLines}
+            bomSearchStates={bomSearchStates}
+            setBomSearchStates={setBomSearchStates}
+            isSubmitting={isSubmitting}
+          />
+        );
+      })()}
+
+      {/* 전개도 그리기 다이얼로그 (절곡품/조립품 공용) */}
+      <DrawingCanvas
+        open={isDrawingOpen}
+        onOpenChange={setIsDrawingOpen}
+        onSave={(imageData) => {
+          setBendingDiagram(imageData);
+          setIsDrawingOpen(false);
+        }}
+        initialImage={bendingDiagram}
+        title={isAssemblyPart ? "조립품 전개도" : "절곡품 전개도"}
+        description={isAssemblyPart
+          ? "조립품 전개도(바라시)를 그리거나 편집합니다."
+          : "절곡품 전개도를 그리거나 편집합니다."
+        }
+      />
     </form>
   );
 }
-
-// 하위 컴포넌트 및 훅 re-export
-export { DynamicFormRenderer } from './DynamicFormRenderer';
-export { DynamicSection } from './DynamicSection';
-export { DynamicField } from './DynamicField';
-export {
-  useFormStructure,
-  useConditionalFields,
-  useDynamicFormState,
-  clearFormStructureCache,
-  invalidateFormStructureCache,
-} from './hooks';
-export * from './types';
-
-export default DynamicItemForm;
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/sections/DynamicBOMSection.tsx b/src/components/items/DynamicItemForm/sections/DynamicBOMSection.tsx
new file mode 100644
index 00000000..b86efad1
--- /dev/null
+++ b/src/components/items/DynamicItemForm/sections/DynamicBOMSection.tsx
@@ -0,0 +1,508 @@
+/**
+ * DynamicBOMSection - 동적 BOM 섹션
+ *
+ * 기존 BOMSection과 100% 동일한 디자인
+ * 품목 검색 API 연동 (/api/proxy/items?search=xxx)
+ */
+
+'use client';
+
+import { Fragment, useState, useEffect, useCallback, useRef } from 'react';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Badge } from '@/components/ui/badge';
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from '@/components/ui/table';
+import {
+  Popover,
+  PopoverAnchor,
+  PopoverContent,
+  PopoverTrigger,
+} from '@/components/ui/popover';
+import {
+  Command,
+  CommandEmpty,
+  CommandGroup,
+  CommandInput,
+  CommandItem,
+  CommandList,
+} from '@/components/ui/command';
+import { Check, Package, Plus, Search, Trash2, Loader2 } from 'lucide-react';
+import type { BOMLine, BOMSearchState, DynamicSection } from '../types';
+
+// 품목 검색 결과 타입
+interface SearchedItem {
+  id: string;
+  itemCode: string;
+  itemName: string;
+  specification?: string;
+  material?: string;
+  unit: string;
+  partType?: string;
+  bendingDiagram?: string;
+}
+
+// Debounce 훅
+function useDebounce<T>(value: T, delay: number): T {
+  const [debouncedValue, setDebouncedValue] = useState<T>(value);
+
+  useEffect(() => {
+    const timer = setTimeout(() => setDebouncedValue(value), delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+
+  return debouncedValue;
+}
+
+export interface DynamicBOMSectionProps {
+  section: DynamicSection;
+  bomLines: BOMLine[];
+  setBomLines: (lines: BOMLine[]) => void;
+  bomSearchStates: Record<string, BOMSearchState>;
+  setBomSearchStates: (states: Record<string, BOMSearchState>) => void;
+  isSubmitting: boolean;
+}
+
+export default function DynamicBOMSection({
+  section,
+  bomLines,
+  setBomLines,
+  bomSearchStates,
+  setBomSearchStates,
+  isSubmitting,
+}: DynamicBOMSectionProps) {
+  // 품목 검색 상태
+  const [searchResults, setSearchResults] = useState<Record<string, SearchedItem[]>>({});
+  const [isSearching, setIsSearching] = useState<Record<string, boolean>>({});
+
+  // 품목 검색 API 호출
+  const searchItems = useCallback(async (lineId: string, query: string) => {
+    if (!query || query.length < 1) {
+      setSearchResults((prev) => ({ ...prev, [lineId]: [] }));
+      return;
+    }
+
+    setIsSearching((prev) => ({ ...prev, [lineId]: true }));
+
+    try {
+      const params = new URLSearchParams();
+      params.append('search', query);
+      params.append('size', '20');
+
+      const response = await fetch(`/api/proxy/items?${params.toString()}`);
+      const result = await response.json();
+
+      if (result.success) {
+        const paginatedData = result.data;
+        const rawItems = paginatedData?.data ?? paginatedData ?? [];
+
+        const mappedItems: SearchedItem[] = rawItems.map((item: Record<string, unknown>) => ({
+          id: String(item.id),
+          itemCode: (item.code ?? item.item_code ?? '') as string,
+          itemName: (item.name ?? item.item_name ?? '') as string,
+          specification: (item.specification ?? '') as string,
+          material: (item.material ?? '') as string,
+          unit: (item.unit ?? 'EA') as string,
+          partType: (item.part_type ?? '') as string,
+          bendingDiagram: (item.bending_diagram ?? '') as string,
+        }));
+
+        setSearchResults((prev) => ({ ...prev, [lineId]: mappedItems }));
+      }
+    } catch (error) {
+      console.error('품목 검색 실패:', error);
+      setSearchResults((prev) => ({ ...prev, [lineId]: [] }));
+    } finally {
+      setIsSearching((prev) => ({ ...prev, [lineId]: false }));
+    }
+  }, []);
+
+  return (
+    <Card>
+      <CardHeader>
+        <div className="flex items-center justify-between">
+          <div>
+            <CardTitle>{section.section.title}</CardTitle>
+            {section.section.description && (
+              <p className="text-sm text-muted-foreground mt-1">
+                {section.section.description}
+              </p>
+            )}
+          </div>
+          <Button
+            type="button"
+            variant="outline"
+            size="sm"
+            onClick={() => {
+              const newLine: BOMLine = {
+                id: `bom-${Date.now()}`,
+                childItemCode: '',
+                childItemName: '',
+                quantity: 1,
+                unit: 'EA',
+              };
+              setBomLines([...bomLines, newLine]);
+            }}
+            disabled={isSubmitting}
+          >
+            <Plus className="h-4 w-4 mr-2" />
+            BOM 품목 추가
+          </Button>
+        </div>
+      </CardHeader>
+      <CardContent>
+        {bomLines.length === 0 ? (
+          <div className="flex flex-col items-center justify-center py-12 text-center">
+            <Package className="h-16 w-16 text-muted-foreground mb-4 opacity-20" />
+            <p className="text-sm text-muted-foreground mb-2">
+              아직 부품 구성이 추가되지 않았습니다
+            </p>
+            <p className="text-xs text-muted-foreground">
+              품목의 구성 부품, 원자재, 부자재를 추가할 수 있습니다
+            </p>
+          </div>
+        ) : (
+          <div className="overflow-x-auto">
+            <Table>
+              <TableHeader>
+                <TableRow>
+                  <TableHead className="w-[280px]">품목코드 / 품목명 입력</TableHead>
+                  <TableHead className="w-[180px]">품목명</TableHead>
+                  <TableHead className="w-[150px]">규격</TableHead>
+                  <TableHead className="w-[100px]">재질</TableHead>
+                  <TableHead className="w-20">수량</TableHead>
+                  <TableHead className="w-16">단위</TableHead>
+                  <TableHead className="w-24 text-right">단가</TableHead>
+                  <TableHead className="w-[180px]">비고</TableHead>
+                  <TableHead className="w-16">삭제</TableHead>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {bomLines.map((line) => (
+                  <BOMLineRow
+                    key={line.id}
+                    line={line}
+                    bomLines={bomLines}
+                    setBomLines={setBomLines}
+                    bomSearchStates={bomSearchStates}
+                    setBomSearchStates={setBomSearchStates}
+                    searchResults={searchResults[line.id] || []}
+                    isSearching={isSearching[line.id] || false}
+                    searchItems={searchItems}
+                  />
+                ))}
+              </TableBody>
+            </Table>
+          </div>
+        )}
+      </CardContent>
+    </Card>
+  );
+}
+
+// BOM 라인 Row 컴포넌트 (검색 debounce 처리용)
+function BOMLineRow({
+  line,
+  bomLines,
+  setBomLines,
+  bomSearchStates,
+  setBomSearchStates,
+  searchResults,
+  isSearching,
+  searchItems,
+}: {
+  line: BOMLine;
+  bomLines: BOMLine[];
+  setBomLines: (lines: BOMLine[]) => void;
+  bomSearchStates: Record<string, BOMSearchState>;
+  setBomSearchStates: (states: Record<string, BOMSearchState>) => void;
+  searchResults: SearchedItem[];
+  isSearching: boolean;
+  searchItems: (lineId: string, query: string) => void;
+}) {
+  const searchState = bomSearchStates[line.id] || { searchValue: '', isOpen: false };
+  const searchValue = searchState.searchValue;
+  const searchOpen = searchState.isOpen;
+
+  // Debounce 검색
+  const debouncedSearchValue = useDebounce(searchValue, 300);
+
+  // 안정적인 검색 함수 ref
+  const searchItemsRef = useRef(searchItems);
+  searchItemsRef.current = searchItems;
+
+  useEffect(() => {
+    if (debouncedSearchValue && searchOpen) {
+      searchItemsRef.current(line.id, debouncedSearchValue);
+    }
+  }, [debouncedSearchValue, searchOpen, line.id]);
+
+  return (
+    <Fragment>
+      <TableRow>
+        <TableCell>
+          <div className="flex gap-1">
+            <Popover
+              open={searchOpen}
+              onOpenChange={(open) => {
+                setBomSearchStates({
+                  ...bomSearchStates,
+                  [line.id]: { ...searchState, isOpen: open },
+                });
+                // 팝오버 열릴 때 검색 실행
+                if (open && searchValue) {
+                  searchItems(line.id, searchValue);
+                }
+              }}
+            >
+              <div className="flex-1 relative">
+                <PopoverAnchor asChild>
+                  <Input
+                    placeholder="품목코드 또는 품목명 입력..."
+                    value={line.childItemCode || searchValue}
+                    onChange={(e) => {
+                      setBomSearchStates({
+                        ...bomSearchStates,
+                        [line.id]: { searchValue: e.target.value, isOpen: true },
+                      });
+                    }}
+                    onFocus={() => {
+                      if (!line.childItemCode) {
+                        setBomSearchStates({
+                          ...bomSearchStates,
+                          [line.id]: { ...searchState, isOpen: true },
+                        });
+                      }
+                    }}
+                    className="w-full"
+                    readOnly={!!line.childItemCode}
+                  />
+                </PopoverAnchor>
+                {line.childItemCode && (
+                  <div className="absolute right-2 top-1/2 -translate-y-1/2 pointer-events-none">
+                    <Check className="h-4 w-4 text-green-600" />
+                  </div>
+                )}
+              </div>
+              <PopoverTrigger asChild>
+                <Button
+                  type="button"
+                  variant="outline"
+                  size="sm"
+                  onClick={() => {
+                    setBomSearchStates({
+                      ...bomSearchStates,
+                      [line.id]: { searchValue: '', isOpen: true },
+                    });
+                  }}
+                >
+                  <Search className="h-4 w-4" />
+                </Button>
+              </PopoverTrigger>
+              <PopoverContent
+                className="w-[400px] p-0"
+                side="bottom"
+                align="start"
+                sideOffset={4}
+              >
+                <Command>
+                  <CommandInput
+                    placeholder="품목코드 또는 품목명 검색..."
+                    value={searchValue}
+                    onValueChange={(value) => {
+                      setBomSearchStates({
+                        ...bomSearchStates,
+                        [line.id]: { ...searchState, searchValue: value },
+                      });
+                    }}
+                  />
+                  <CommandList>
+                    {isSearching ? (
+                      <div className="flex items-center justify-center py-6">
+                        <Loader2 className="h-4 w-4 animate-spin mr-2" />
+                        <span className="text-sm text-muted-foreground">검색 중...</span>
+                      </div>
+                    ) : searchResults.length === 0 ? (
+                      <CommandEmpty>
+                        {searchValue ? '검색 결과가 없습니다.' : '품목코드 또는 품목명을 입력하세요.'}
+                      </CommandEmpty>
+                    ) : (
+                      <CommandGroup>
+                        {searchResults.map((item) => (
+                          <CommandItem
+                            key={item.id}
+                            value={`${item.itemCode} ${item.itemName}`}
+                            onSelect={() => {
+                              const isBendingPart = item.partType === 'BENDING';
+
+                              setBomLines(
+                                bomLines.map((l) =>
+                                  l.id === line.id
+                                    ? {
+                                        ...l,
+                                        childItemCode: item.itemCode || '',
+                                        childItemName: item.itemName || '',
+                                        specification: item.specification || '',
+                                        material: item.material || '',
+                                        unit: item.unit || 'EA',
+                                        unitPrice: 0,
+                                        isBending: isBendingPart,
+                                        bendingDiagram: isBendingPart
+                                          ? item.bendingDiagram
+                                          : undefined,
+                                      }
+                                    : l
+                                )
+                              );
+                              setBomSearchStates({
+                                ...bomSearchStates,
+                                [line.id]: { searchValue: '', isOpen: false },
+                              });
+                            }}
+                            className="cursor-pointer"
+                          >
+                            <div className="flex items-center justify-between w-full">
+                              <div className="flex-1">
+                                <div className="flex items-center gap-2">
+                                  <code className="text-xs bg-gray-100 px-2 py-0.5 rounded">
+                                    {item.itemCode}
+                                  </code>
+                                  <span className="text-sm">{item.itemName}</span>
+                                  {item.specification && (
+                                    <span className="text-xs text-muted-foreground">
+                                      ({item.specification})
+                                    </span>
+                                  )}
+                                </div>
+                              </div>
+                              <Badge variant="secondary" className="ml-2">
+                                {item.unit}
+                              </Badge>
+                            </div>
+                          </CommandItem>
+                        ))}
+                      </CommandGroup>
+                    )}
+                  </CommandList>
+                </Command>
+              </PopoverContent>
+            </Popover>
+          </div>
+        </TableCell>
+        <TableCell className="text-sm">{line.childItemName || '-'}</TableCell>
+        <TableCell className="text-sm text-muted-foreground">
+          {line.specification || '-'}
+        </TableCell>
+        <TableCell className="text-sm">
+          <Input
+            value={line.material || ''}
+            onChange={(e) => {
+              setBomLines(
+                bomLines.map((l) =>
+                  l.id === line.id ? { ...l, material: e.target.value } : l
+                )
+              );
+            }}
+            placeholder="재질"
+            className="w-full text-xs"
+          />
+        </TableCell>
+        <TableCell>
+          <Input
+            type="number"
+            value={line.quantity}
+            onChange={(e) => {
+              setBomLines(
+                bomLines.map((l) =>
+                  l.id === line.id ? { ...l, quantity: Number(e.target.value) } : l
+                )
+              );
+            }}
+            min="0"
+            step="0.01"
+            className="w-full"
+          />
+        </TableCell>
+        <TableCell>
+          <Badge variant="secondary">{line.unit}</Badge>
+        </TableCell>
+        <TableCell>
+          <Input
+            type="number"
+            value={line.unitPrice || 0}
+            onChange={(e) => {
+              setBomLines(
+                bomLines.map((l) =>
+                  l.id === line.id ? { ...l, unitPrice: Number(e.target.value) } : l
+                )
+              );
+            }}
+            min="0"
+            className="w-full text-right"
+          />
+        </TableCell>
+        <TableCell>
+          <Input
+            value={line.note || ''}
+            onChange={(e) => {
+              setBomLines(
+                bomLines.map((l) =>
+                  l.id === line.id ? { ...l, note: e.target.value } : l
+                )
+              );
+            }}
+            placeholder="비고"
+            className="w-full text-xs"
+          />
+        </TableCell>
+        <TableCell>
+          <Button
+            type="button"
+            variant="ghost"
+            size="sm"
+            onClick={() => {
+              setBomLines(bomLines.filter((l) => l.id !== line.id));
+            }}
+          >
+            <Trash2 className="h-4 w-4 text-red-600" />
+          </Button>
+        </TableCell>
+      </TableRow>
+
+      {/* 절곡품인 경우 전개도 정보 표시 */}
+      {line.isBending && line.bendingDiagram && (
+        <TableRow>
+          <TableCell colSpan={9} className="bg-blue-50 p-4">
+            <div className="space-y-3">
+              <div className="flex items-center gap-2">
+                <Badge variant="outline" className="bg-blue-100 text-blue-700">
+                  절곡품 전개도 정보
+                </Badge>
+              </div>
+
+              {/* 전개도 이미지 */}
+              <div>
+                <Label className="text-xs mb-2 block">전개도 이미지</Label>
+                <div className="border rounded-lg p-2 bg-white">
+                  <img
+                    src={line.bendingDiagram}
+                    alt="절곡 전개도"
+                    className="max-w-full h-auto max-h-[300px] object-contain mx-auto"
+                  />
+                </div>
+              </div>
+            </div>
+          </TableCell>
+        </TableRow>
+      )}
+    </Fragment>
+  );
+}
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/sections/index.ts b/src/components/items/DynamicItemForm/sections/index.ts
new file mode 100644
index 00000000..73fcf96f
--- /dev/null
+++ b/src/components/items/DynamicItemForm/sections/index.ts
@@ -0,0 +1,2 @@
+export { default as DynamicBOMSection } from './DynamicBOMSection';
+export type { DynamicBOMSectionProps } from './DynamicBOMSection';
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/types.ts b/src/components/items/DynamicItemForm/types.ts
index 8b59fc71..86ccba09 100644
--- a/src/components/items/DynamicItemForm/types.ts
+++ b/src/components/items/DynamicItemForm/types.ts
@@ -1,402 +1,244 @@
 /**
- * 동적 폼 렌더링 타입 정의
+ * DynamicItemForm 타입 정의
  *
- * API 응답 구조와 동적 폼 컴포넌트에서 사용하는 타입들
- * 참조: [PLAN-2025-11-28] dynamic-item-form-implementation.md
+ * 품목기준관리 API 기반 동적 폼 렌더링용 타입
  */
 
-import type { ItemType, PartType } from '@/types/item';
+import type {
+  ItemPageResponse,
+  ItemSectionResponse,
+  ItemFieldResponse,
+  BomItemResponse,
+  PageStructureResponse,
+} from '@/types/item-master-api';
 
-// ===== 필드 타입 =====
+// ============================================
+// 조건부 표시 타입
+// ============================================
 
 /**
- * 필드 입력 타입
+ * 조건부 표시 설정 - 개별 조건
  */
-export type FieldType =
-  | 'textbox'           // 단일 텍스트 입력
-  | 'textarea'          // 여러 줄 텍스트
-  | 'dropdown'          // 선택 목록
-  | 'searchable-dropdown' // 검색 가능 선택
-  | 'number'            // 숫자 입력
-  | 'currency'          // 통화 입력
-  | 'date'              // 날짜 선택
-  | 'date-range'        // 기간 선택
-  | 'checkbox'          // 체크박스
-  | 'switch'            // 토글 스위치
-  | 'file'              // 파일 업로드
-  | 'custom:drawing-canvas'     // 전개도 그리기
-  | 'custom:bending-detail-table' // 전개도 상세 입력
-  | 'custom:bom-table'; // BOM 관리 테이블
-
-/**
- * 섹션 타입
- */
-export type SectionType =
-  | 'BASIC'        // 기본 정보
-  | 'DETAIL'       // 상세 정보
-  | 'BOM'          // 부품 구성
-  | 'BENDING'      // 절곡 정보
-  | 'CERTIFICATION'// 인정 정보
-  | 'CUSTOM';      // 커스텀
-
-// ===== 유효성 검증 =====
-
-/**
- * 필드 유효성 검증 규칙
- */
-export interface ValidationRules {
-  maxLength?: number;
-  minLength?: number;
-  max?: number;
-  min?: number;
-  pattern?: string;
-  patternMessage?: string;
-  custom?: string; // 커스텀 검증 함수 이름
-}
-
-// ===== 조건부 렌더링 =====
-
-/**
- * 조건 연산자
- */
-export type ConditionOperator =
-  | 'equals'
-  | 'not_equals'
-  | 'in'
-  | 'not_in'
-  | 'contains'
-  | 'greater_than'
-  | 'less_than';
-
-/**
- * 조건 정의
- */
-export interface Condition {
-  field_key: string;
-  operator: ConditionOperator;
-  value: string | number | boolean | string[];
+export interface FieldConditionConfig {
+  fieldKey: string;           // 조건을 가진 필드의 키
+  expectedValue: string;      // 이 값일 때
+  targetFieldIds?: string[];  // 이 필드들 표시
+  targetSectionIds?: string[]; // 이 섹션들 표시
 }
 
 /**
- * 조건부 섹션 표시 규칙
+ * 필드의 display_condition 구조
  */
-export interface ConditionalSection {
-  condition: Condition;
-  show_sections: number[];
-  hide_sections?: number[];
+export interface DisplayCondition {
+  targetType: 'field' | 'section';
+  fieldConditions?: FieldConditionConfig[];
+  sectionIds?: string[]; // legacy 지원
 }
 
 /**
- * 조건부 필드 표시 규칙
+ * 단순화된 단위 옵션 타입 (필드 컴포넌트용)
  */
-export interface ConditionalField {
-  condition: Condition;
-  show_fields: number[];
-  hide_fields?: number[];
-}
-
-// ===== 필드 옵션 =====
-
-/**
- * 드롭다운 옵션
- */
-export interface DropdownOption {
+export interface SimpleUnitOption {
+  label: string;
   value: string;
-  label: string;
-  disabled?: boolean;
 }
 
+// ============================================
+// 폼 구조 타입
+// ============================================
+
 /**
- * 드롭다운 설정
+ * 동적 폼에 사용되는 페이지 구조
  */
-export interface DropdownConfig {
-  options?: DropdownOption[];
-  options_endpoint?: string; // API에서 옵션 로드
-  placeholder?: string;
-  allow_empty?: boolean;
-  searchable?: boolean;
+export interface DynamicFormStructure {
+  page: ItemPageResponse;
+  sections: DynamicSection[];
+  directFields: DynamicField[];
 }
 
 /**
- * 파일 업로드 설정
- */
-export interface FileConfig {
-  accept?: string; // 허용 파일 타입 (예: ".pdf,.doc")
-  max_size?: number; // 최대 파일 크기 (bytes)
-  multiple?: boolean;
-  upload_endpoint?: string;
-}
-
-// ===== BOM 섹션 설정 =====
-
-/**
- * BOM 컬럼 정의
- */
-export interface BOMColumn {
-  key: string;
-  label: string;
-  width?: number;
-  type?: 'text' | 'number' | 'dropdown';
-  editable?: boolean;
-}
-
-/**
- * BOM 섹션 설정
- */
-export interface BOMConfig {
-  columns: BOMColumn[];
-  allow_search: boolean;
-  search_endpoint?: string;
-  allow_add: boolean;
-  allow_delete: boolean;
-  allow_reorder?: boolean;
-}
-
-// ===== 동적 필드 =====
-
-/**
- * 동적 필드 정의
- * API 응답: sections[].fields[]
- */
-export interface DynamicField {
-  id: number;
-  field_name: string;        // 표시 이름 (예: "품목명")
-  field_key: string;         // 데이터 키 (예: "item_name")
-  field_type: FieldType;
-  order_no: number;
-  is_required: boolean;
-  is_readonly?: boolean;
-  placeholder?: string;
-  default_value?: string | number | boolean;
-  validation_rules?: ValidationRules;
-  help_text?: string;
-
-  // 그리드 레이아웃
-  grid_row?: number;
-  grid_col?: number;
-  grid_span?: number; // 1-4 (4 = 전체 너비)
-
-  // 타입별 설정
-  dropdown_config?: DropdownConfig;
-  file_config?: FileConfig;
-
-  // 조건부 표시
-  display_condition?: Condition;
-}
-
-// ===== 동적 섹션 =====
-
-/**
- * 동적 섹션 정의
- * API 응답: sections[]
+ * 동적 섹션 (순서 포함)
  */
 export interface DynamicSection {
-  id: number;
-  title: string;
-  description?: string;
-  section_type: SectionType;
-  order_no: number;
-  is_collapsible: boolean;
-  is_default_open: boolean;
-
-  // 섹션 내 필드들
+  section: ItemSectionResponse;
+  orderNo: number;
   fields: DynamicField[];
-
-  // BOM 섹션인 경우
-  bom_config?: BOMConfig;
-
-  // 조건부 표시 (섹션 레벨)
-  display_condition?: Condition;
-}
-
-// ===== 페이지 정의 =====
-
-/**
- * 페이지 정보
- * API 응답: page
- */
-export interface PageInfo {
-  id: number;
-  page_name: string;
-  item_type: ItemType;
-  part_type?: PartType; // PT인 경우에만
-  description?: string;
-  is_active: boolean;
-}
-
-// ===== API 응답 구조 =====
-
-/**
- * 폼 구조 API 응답
- * GET /api/v1/item-master/form-structure/{item_type}
- */
-export interface FormStructureResponse {
-  success: boolean;
-  data: {
-    page: PageInfo;
-    sections: DynamicSection[];
-    conditional_sections?: ConditionalSection[];
-    conditional_fields?: ConditionalField[];
-  };
-  message?: string;
+  bomItems: DynamicBomItem[];
 }
 
 /**
- * 폼 구조 데이터 (클라이언트용)
+ * 동적 필드 (순서 포함)
  */
-export interface FormStructure {
-  page: PageInfo;
-  sections: DynamicSection[];
-  conditionalSections: ConditionalSection[];
-  conditionalFields: ConditionalField[];
-}
-
-// ===== 폼 상태 =====
-
-/**
- * 폼 값 타입
- */
-export type FormValue = string | number | boolean | null | undefined | File | File[];
-
-/**
- * 폼 데이터 (동적 키-값 쌍)
- */
-export type FormData = Record<string, FormValue>;
-
-/**
- * 필드 에러 상태
- */
-export interface FieldError {
-  field_key: string;
-  message: string;
+export interface DynamicField {
+  field: ItemFieldResponse;
+  orderNo: number;
 }
 
 /**
- * 폼 상태
+ * 동적 BOM 항목 (순서 포함)
  */
-export interface FormState {
-  values: FormData;
-  errors: Record<string, string>;
-  touched: Record<string, boolean>;
-  isSubmitting: boolean;
-  isValid: boolean;
+export interface DynamicBomItem {
+  bomItem: BomItemResponse;
+  orderNo: number;
 }
 
-// ===== 컴포넌트 Props =====
+// ============================================
+// BOM 관련 타입
+// ============================================
 
 /**
- * DynamicField 컴포넌트 Props
+ * BOM 라인 (폼에서 사용하는 BOM 항목)
  */
-export interface DynamicFieldProps {
-  field: DynamicField;
-  value: FormValue;
+export interface BOMLine {
+  id: string;
+  childItemCode: string;
+  childItemName: string;
+  specification?: string;
+  material?: string;
+  quantity: number;
+  unit: string;
+  unitPrice?: number;
+  note?: string;
+  isBending?: boolean;
+  bendingDiagram?: string;
+}
+
+/**
+ * BOM 검색 상태
+ */
+export interface BOMSearchState {
+  searchValue: string;
+  isOpen: boolean;
+}
+
+// ============================================
+// 폼 상태 타입
+// ============================================
+
+/**
+ * 동적 폼 필드 값 타입
+ */
+export type DynamicFieldValue = string | number | boolean | null | undefined | Record<string, unknown>[] | Record<string, unknown>;
+
+/**
+ * 동적 폼 데이터 (field_key를 key로 사용)
+ */
+export type DynamicFormData = Record<string, DynamicFieldValue>;
+
+/**
+ * 동적 폼 에러
+ */
+export type DynamicFormErrors = Record<string, string>;
+
+// ============================================
+// 컴포넌트 Props 타입
+// ============================================
+
+/**
+ * DynamicItemForm 메인 컴포넌트 Props
+ */
+export interface DynamicItemFormProps {
+  mode: 'create' | 'edit';
+  itemType: 'FG' | 'PT' | 'SM' | 'RM' | 'CS';
+  initialData?: DynamicFormData;
+  onSubmit: (data: DynamicFormData) => Promise<void>;
+}
+
+/**
+ * 동적 필드 렌더러 Props
+ */
+export interface DynamicFieldRendererProps {
+  field: ItemFieldResponse;
+  value: DynamicFieldValue;
+  onChange: (value: DynamicFieldValue) => void;
   error?: string;
-  onChange: (value: FormValue) => void;
-  onBlur: () => void;
   disabled?: boolean;
+  unitOptions?: SimpleUnitOption[];
 }
 
 /**
- * DynamicSection 컴포넌트 Props
+ * 동적 섹션 렌더러 Props
  */
-export interface DynamicSectionProps {
+export interface DynamicSectionRendererProps {
   section: DynamicSection;
-  values: FormData;
-  errors: Record<string, string>;
-  onChange: (fieldKey: string, value: FormValue) => void;
-  onBlur: (fieldKey: string) => void;
+  formData: DynamicFormData;
+  errors: DynamicFormErrors;
+  onChange: (fieldKey: string, value: DynamicFieldValue) => void;
   disabled?: boolean;
+  unitOptions?: SimpleUnitOption[];
 }
 
-/**
- * DynamicFormRenderer 컴포넌트 Props
- */
-export interface DynamicFormRendererProps {
-  sections: DynamicSection[];
-  conditionalSections: ConditionalSection[];
-  conditionalFields: ConditionalField[];
-  values: FormData;
-  errors: Record<string, string>;
-  onChange: (fieldKey: string, value: FormValue) => void;
-  onBlur: (fieldKey: string) => void;
-  disabled?: boolean;
-}
-
-// ===== 훅 반환 타입 =====
+// ============================================
+// Hook 반환 타입
+// ============================================
 
 /**
  * useFormStructure 훅 반환 타입
  */
-export interface UseFormStructureReturn {
-  formStructure: FormStructure | null;
+export interface UseFormStructureResult {
+  structure: DynamicFormStructure | null;
   isLoading: boolean;
-  error: Error | null;
+  error: string | null;
+  unitOptions: SimpleUnitOption[];
   refetch: () => Promise<void>;
 }
 
 /**
  * useDynamicFormState 훅 반환 타입
  */
-export interface UseDynamicFormStateReturn {
-  state: FormState;
-  setValue: (fieldKey: string, value: FormValue) => void;
-  setValues: (values: FormData) => void;
-  setError: (fieldKey: string, message: string) => void;
+export interface UseDynamicFormStateResult {
+  formData: DynamicFormData;
+  errors: DynamicFormErrors;
+  isSubmitting: boolean;
+  setFieldValue: (fieldKey: string, value: DynamicFieldValue) => void;
+  setError: (fieldKey: string, error: string) => void;
   clearError: (fieldKey: string) => void;
-  setTouched: (fieldKey: string) => void;
-  validate: () => boolean;
-  reset: (initialValues?: FormData) => void;
-  handleSubmit: (onSubmit: (data: FormData) => Promise<void>) => (e: React.FormEvent) => Promise<void>;
+  clearAllErrors: () => void;
+  validateField: (field: ItemFieldResponse, value: DynamicFieldValue) => string | null;
+  validateAll: (fields: ItemFieldResponse[]) => boolean;
+  handleSubmit: (onSubmit: (data: DynamicFormData) => Promise<void>) => Promise<void>;
+  resetForm: (initialData?: DynamicFormData) => void;
 }
 
-/**
- * useConditionalFields 훅 반환 타입
- */
-export interface UseConditionalFieldsReturn {
-  visibleSections: number[];
-  visibleFields: Record<number, number[]>; // sectionId -> fieldIds
-  isFieldVisible: (sectionId: number, fieldId: number) => boolean;
-  isSectionVisible: (sectionId: number) => boolean;
-}
-
-// ===== 유틸리티 타입 =====
+// ============================================
+// 유틸리티 타입
+// ============================================
 
 /**
- * 필드 타입 → 기본값 매핑
+ * 필드 타입별 입력 컴포넌트 매핑
  */
-export const FIELD_TYPE_DEFAULTS: Record<FieldType, FormValue> = {
-  textbox: '',
-  textarea: '',
-  dropdown: '',
-  'searchable-dropdown': '',
-  number: 0,
-  currency: 0,
-  date: null,
-  'date-range': null,
-  checkbox: false,
-  switch: false,
-  file: null,
-  'custom:drawing-canvas': null,
-  'custom:bending-detail-table': null,
-  'custom:bom-table': null,
+export type FieldTypeComponentMap = {
+  textbox: 'TextField';
+  number: 'NumberField';
+  dropdown: 'DropdownField';
+  checkbox: 'CheckboxField';
+  date: 'DateField';
+  textarea: 'TextareaField';
 };
 
 /**
- * 필드 타입 → 컴포넌트 이름 매핑
+ * API 응답을 DynamicFormStructure로 변환
  */
-export const FIELD_TYPE_COMPONENTS: Record<FieldType, string> = {
-  textbox: 'TextField',
-  textarea: 'TextField',
-  dropdown: 'DropdownField',
-  'searchable-dropdown': 'DropdownField',
-  number: 'NumberField',
-  currency: 'NumberField',
-  date: 'DateField',
-  'date-range': 'DateField',
-  checkbox: 'CheckboxField',
-  switch: 'CheckboxField',
-  file: 'FileField',
-  'custom:drawing-canvas': 'CustomField',
-  'custom:bending-detail-table': 'CustomField',
-  'custom:bom-table': 'CustomField',
-};
\ No newline at end of file
+export function convertToFormStructure(
+  response: PageStructureResponse
+): DynamicFormStructure {
+  return {
+    page: response.page,
+    sections: response.sections.map((s) => ({
+      section: s.section,
+      orderNo: s.order_no,
+      fields: s.fields.map((f) => ({
+        field: f.field,
+        orderNo: f.order_no,
+      })),
+      bomItems: s.bom_items.map((b) => ({
+        bomItem: b.bom_item,
+        orderNo: b.order_no,
+      })),
+    })),
+    directFields: response.direct_fields.map((f) => ({
+      field: f.field,
+      orderNo: f.order_no,
+    })),
+  };
+}
\ No newline at end of file
diff --git a/src/components/items/DynamicItemForm/utils/itemCodeGenerator.ts b/src/components/items/DynamicItemForm/utils/itemCodeGenerator.ts
new file mode 100644
index 00000000..3fd60a66
--- /dev/null
+++ b/src/components/items/DynamicItemForm/utils/itemCodeGenerator.ts
@@ -0,0 +1,377 @@
+/**
+ * 품목코드/품목명 자동생성 유틸리티
+ *
+ * MVP용 프론트엔드 구현 - 하드코딩 내역은 추후 백엔드 API로 이관 필요
+ *
+ * @see claudedocs/item-master/[REF] item-code-hardcoding.md
+ */
+
+// ============================================
+// [하드코딩] 영문약어 매핑 테이블
+// TODO: 추후 백엔드 API 또는 품목기준관리에서 설정 가능하도록 변경
+// ============================================
+export const ITEM_CODE_PREFIX_MAP: Record<string, string> = {
+  // 부품 - 조립품
+  '가이드레일': 'GR',
+  '케이스': 'CASE',
+  '브라켓': 'BRK',
+
+  // 부품 - 구매품
+  '모터': 'MOTOR',
+  '제어기': 'CTL',
+  '전동개폐기': 'OPENER',
+  '스위치': 'SW',
+  '센서': 'SENSOR',
+  '리모컨': 'REMOTE',
+
+  // 부품 - 절곡품
+  '레일': 'RAIL',
+  '커버': 'COVER',
+  '플레이트': 'PLATE',
+
+  // 제품
+  '스크린': 'SCREEN',
+  '셔터': 'SHUTTER',
+  '방화스크린': 'FIRE-SCR',
+  '롤스크린': 'ROLL-SCR',
+
+  // 원자재
+  '알루미늄': 'ALU',
+  '스틸': 'STEEL',
+  '철판': 'STEEL',
+
+  // 부자재/소모품
+  '볼트': 'BOLT',
+  '너트': 'NUT',
+  '와셔': 'WASHER',
+  '나사': 'SCREW',
+};
+
+// ============================================
+// [하드코딩] 절곡품 코드 체계
+// TODO: 추후 품목기준관리에서 설정 가능하도록 변경
+// ============================================
+export const BENDING_CODE_SYSTEM = {
+  // 품목명코드 (category2)
+  품목명코드: {
+    'R': '가이드레일',
+    'S': '스크린',
+    'C': '케이스',
+    'B': '박스',
+    'T': '트림',
+    'L': '라스틱',
+    'G': '기타',
+  } as Record<string, string>,
+
+  // 종류코드 (category3)
+  종류코드: {
+    'M': '마감',
+    'T': '티',
+    'C': '채널',
+    'D': '단면',
+    'S': '상부',
+    'U': '하부',
+    'F': '플랫',
+    'P': '피스',
+    'L': '리드',
+    'B': '브라켓',
+    'E': '엔드',
+    'I': '이음',
+    'A': '각재',
+  } as Record<string, string>,
+
+  // 길이코드 매핑 (mm → 코드)
+  길이코드: {
+    1219: '12',
+    2438: '24',
+    3000: '30',
+    3500: '35',
+    4000: '40',
+    4150: '41',
+    4200: '42',
+    4300: '43',
+  } as Record<number, string>,
+};
+
+// ============================================
+// [하드코딩] 조립품 설치유형 매핑
+// TODO: 추후 품목기준관리에서 설정 가능하도록 변경
+// ============================================
+export const INSTALLATION_TYPE_MAP: Record<string, string> = {
+  'standard': '표준형',
+  'top': '상부형',
+  'bottom': '하부형',
+  'side': '측면형',
+  'custom': '맞춤형',
+};
+
+/**
+ * 품목명에서 영문약어 추출
+ * @param itemName 품목명 (한글)
+ * @returns 영문약어 또는 기본값
+ */
+export function getItemCodePrefix(itemName: string): string {
+  // 정확한 매칭 먼저 시도
+  if (ITEM_CODE_PREFIX_MAP[itemName]) {
+    return ITEM_CODE_PREFIX_MAP[itemName];
+  }
+
+  // 부분 매칭 시도 (품목명에 키워드가 포함된 경우)
+  for (const [keyword, prefix] of Object.entries(ITEM_CODE_PREFIX_MAP)) {
+    if (itemName.includes(keyword)) {
+      return prefix;
+    }
+  }
+
+  // 매칭 실패 시 품목명의 첫 글자들로 생성 (임시)
+  // 예: "새로운품목" → "ITEM" (기본값)
+  return 'ITEM';
+}
+
+/**
+ * 기존 품목 목록에서 다음 순번 계산
+ * @param existingCodes 기존 품목코드 배열 (예: ["GR-001", "GR-002"])
+ * @param prefix 영문약어 (예: "GR")
+ * @returns 다음 순번 (예: "003")
+ */
+export function getNextSequence(existingCodes: string[], prefix: string): string {
+  const pattern = new RegExp(`^${prefix}-(\\d+)$`, 'i');
+
+  let maxSeq = 0;
+  existingCodes.forEach(code => {
+    const match = code.match(pattern);
+    if (match) {
+      const seq = parseInt(match[1], 10);
+      if (seq > maxSeq) {
+        maxSeq = seq;
+      }
+    }
+  });
+
+  return String(maxSeq + 1).padStart(3, '0');
+}
+
+/**
+ * 품목코드 생성 (영문약어-순번)
+ * @param itemName 품목명 (한글)
+ * @param existingCodes 기존 품목코드 배열
+ * @returns 새 품목코드 (예: "GR-003")
+ */
+export function generateItemCode(itemName: string, existingCodes: string[]): string {
+  const prefix = getItemCodePrefix(itemName);
+  const sequence = getNextSequence(existingCodes, prefix);
+  return `${prefix}-${sequence}`;
+}
+
+/**
+ * 절곡품 품목코드 생성 (품목명코드 + 종류코드 + 길이코드)
+ * @param category2 품목명코드 (R, S, C 등)
+ * @param category3 종류코드 (M, T, C 등)
+ * @param lengthMm 길이 (mm)
+ * @returns 품목코드 (예: "RC24")
+ */
+export function generateBendingItemCode(
+  category2: string,
+  category3: string,
+  lengthMm: number
+): string {
+  // 길이코드 변환
+  let lengthCode = BENDING_CODE_SYSTEM.길이코드[lengthMm];
+  if (!lengthCode) {
+    // 매핑에 없으면 100으로 나눈 값 사용
+    lengthCode = String(Math.floor(lengthMm / 100)).padStart(2, '0');
+  }
+
+  return `${category2}${category3}${lengthCode}`;
+}
+
+/**
+ * 조립품 품목명 생성 (품목명 + 설치유형 + 측면규격*길이코드)
+ * @param itemName 기본 품목명 (가이드레일)
+ * @param installationType 설치유형 (standard → 표준형)
+ * @param sideSpecWidth 측면규격 너비
+ * @param sideSpecHeight 측면규격 높이
+ * @param lengthMm 길이 (mm)
+ * @returns 조합된 품목명 (예: "가이드레일표준형50*60*24")
+ */
+export function generateAssemblyItemName(
+  itemName: string,
+  installationType: string,
+  sideSpecWidth?: number,
+  sideSpecHeight?: number,
+  lengthMm?: number
+): string {
+  const installationTypeKorean = INSTALLATION_TYPE_MAP[installationType] || installationType;
+
+  let result = `${itemName}${installationTypeKorean}`;
+
+  if (sideSpecWidth && sideSpecHeight && lengthMm) {
+    // 길이코드 변환
+    let lengthCode = BENDING_CODE_SYSTEM.길이코드[lengthMm];
+    if (!lengthCode) {
+      lengthCode = String(Math.floor(lengthMm / 100)).padStart(2, '0');
+    }
+
+    result += `${sideSpecWidth}*${sideSpecHeight}*${lengthCode}`;
+  }
+
+  return result;
+}
+
+/**
+ * 절곡품 품목명 생성 (품목명 + 종류 + 규격)
+ * @param category2Label 품목명 라벨 (가이드레일)
+ * @param category3Label 종류 라벨 (채널)
+ * @param specification 규격
+ * @returns 조합된 품목명
+ */
+export function generateBendingItemName(
+  category2Label: string,
+  category3Label: string,
+  specification?: string
+): string {
+  let result = `${category2Label} ${category3Label}`;
+  if (specification) {
+    result += ` ${specification}`;
+  }
+  return result;
+}
+
+/**
+ * 구매품 품목명 생성 (품목명 + 규격)
+ * @param itemName 기본 품목명
+ * @param specification 규격
+ * @returns 조합된 품목명 (예: "모터 0.4KW")
+ */
+export function generatePurchasedItemName(
+  itemName: string,
+  specification?: string
+): string {
+  if (specification) {
+    return `${itemName} ${specification}`;
+  }
+  return itemName;
+}
+
+// ============================================
+// 절곡 부품 품목코드 자동생성 (간소화 버전)
+// 2025-12-03 추가
+// ============================================
+
+/**
+ * 문자열에서 마지막 괄호 안의 단일 문자 추출
+ * @param str 입력 문자열 (예: "가이드레일(벽면형) (R)")
+ * @returns 괄호 안의 문자 (예: "R") 또는 빈 문자열
+ */
+export function extractParenthesisCode(str: string): string {
+  if (!str) return '';
+
+  // 마지막 괄호 안의 내용 추출 (예: "(R)" → "R")
+  const match = str.match(/\(([A-Za-z가-힣])\)\s*$/);
+  if (match) {
+    return match[1];
+  }
+
+  // 대안: 마지막 괄호가 없으면 앞쪽 괄호에서 추출 시도
+  const altMatch = str.match(/\(([A-Za-z가-힣])\)/);
+  return altMatch ? altMatch[1] : '';
+}
+
+/**
+ * 절곡품 품목코드 생성 (품목명코드 + 종류코드)
+ * @param itemNameValue 품목명 드롭다운 값 (예: "가이드레일(벽면형) (R)")
+ * @param categoryValue 종류 드롭다운 값 (예: "본체 (M)")
+ * @param shapeLengthValue 모양&길이 드롭다운 값 (예: "2438" 또는 "30")
+ * @returns 품목코드 (예: "RM" 또는 "RM30")
+ */
+export function generateBendingItemCodeSimple(
+  itemNameValue: string,
+  categoryValue: string,
+  shapeLengthValue?: string
+): string {
+  const itemNameCode = extractParenthesisCode(itemNameValue);
+  const categoryCode = extractParenthesisCode(categoryValue);
+
+  if (!itemNameCode && !categoryValue) return '';
+
+  let code = `${itemNameCode}${categoryCode}`;
+
+  // 모양&길이가 있으면 길이 축약 추가
+  if (shapeLengthValue) {
+    // 숫자만 추출
+    const lengthNum = parseInt(shapeLengthValue.replace(/[^0-9]/g, ''), 10);
+    if (lengthNum > 0) {
+      // 100으로 나눈 값 (예: 2438 → 24, 3000 → 30)
+      const lengthCode = Math.floor(lengthNum / 100).toString();
+      code += lengthCode;
+    }
+  }
+
+  return code;
+}
+
+// ============================================
+// 조립 부품 품목명/규격 자동생성
+// 2025-12-03 추가
+// ============================================
+
+/**
+ * 조립 부품 품목명 생성 (품목명 + 가로x세로)
+ * @param itemName 선택한 품목명 (가이드레일)
+ * @param sideSpecWidth 측면규격 가로 (mm)
+ * @param sideSpecHeight 측면규격 세로 (mm)
+ * @returns 조합된 품목명 (예: "가이드레일 50x60")
+ */
+export function generateAssemblyItemNameSimple(
+  itemName: string,
+  sideSpecWidth?: number | string,
+  sideSpecHeight?: number | string
+): string {
+  if (!itemName) return '';
+
+  if (sideSpecWidth && sideSpecHeight) {
+    return `${itemName} ${sideSpecWidth}x${sideSpecHeight}`;
+  }
+
+  return itemName;
+}
+
+/**
+ * 조립 부품 규격 생성 (가로x세로x길이)
+ * @param sideSpecWidth 측면규격 가로 (mm)
+ * @param sideSpecHeight 측면규격 세로 (mm)
+ * @param assemblyLength 길이 (mm) - 네자리 그대로 사용
+ * @returns 조합된 규격 (예: "50x60x2438")
+ */
+export function generateAssemblySpecification(
+  sideSpecWidth?: number | string,
+  sideSpecHeight?: number | string,
+  assemblyLength?: number | string
+): string {
+  if (!sideSpecWidth || !sideSpecHeight || !assemblyLength) {
+    return '';
+  }
+
+  return `${sideSpecWidth}x${sideSpecHeight}x${assemblyLength}`;
+}
+
+// ============================================
+// 하드코딩 내역 목록 (문서화용)
+// ============================================
+export const HARDCODED_ITEMS = {
+  ITEM_CODE_PREFIX_MAP: {
+    description: '품목명 → 영문약어 매핑 테이블',
+    location: 'itemCodeGenerator.ts',
+    migrationTarget: '품목기준관리 API 또는 별도 설정 테이블',
+  },
+  BENDING_CODE_SYSTEM: {
+    description: '절곡품 코드 체계 (품목명코드, 종류코드, 길이코드)',
+    location: 'itemCodeGenerator.ts',
+    migrationTarget: '품목기준관리 API 또는 별도 설정 테이블',
+  },
+  INSTALLATION_TYPE_MAP: {
+    description: '조립품 설치유형 매핑',
+    location: 'itemCodeGenerator.ts',
+    migrationTarget: '품목기준관리 API 또는 별도 설정 테이블',
+  },
+};
\ No newline at end of file
diff --git a/src/components/items/ItemFormWrapper.tsx b/src/components/items/ItemFormWrapper.tsx
deleted file mode 100644
index 0849ea62..00000000
--- a/src/components/items/ItemFormWrapper.tsx
+++ /dev/null
@@ -1,200 +0,0 @@
-/**
- * ItemFormWrapper - Feature Flag 기반 폼 전환 래퍼
- *
- * 기존 ItemForm과 새 DynamicItemForm 간 전환을 제어
- * - 환경변수 또는 localStorage로 제어 가능
- * - 품목 유형별로 다르게 적용 가능
- *
- * @example
- * // 기존과 동일하게 사용
- * <ItemFormWrapper mode="create" onSubmit={handleSubmit} />
- *
- * // 동적 폼 강제 사용
- * <ItemFormWrapper mode="create" onSubmit={handleSubmit} useDynamicForm />
- */
-
-'use client';
-
-import { useState, useEffect } from 'react';
-import type { ItemType } from '@/types/item';
-import type { CreateItemFormData } from '@/lib/utils/validation';
-import ItemForm from './ItemForm';
-import DynamicItemForm from './DynamicItemForm';
-import type { FormData } from './DynamicItemForm/types';
-
-// Feature Flag 설정
-const FEATURE_FLAGS = {
-  // 환경변수로 전체 활성화 (기본값: false)
-  ENABLE_DYNAMIC_FORM: process.env.NEXT_PUBLIC_ENABLE_DYNAMIC_FORM === 'true',
-
-  // 품목 유형별 활성화 (점진적 마이그레이션용)
-  ENABLED_ITEM_TYPES: ['FG'] as ItemType[], // 초기에는 FG만 활성화
-};
-
-interface ItemFormWrapperProps {
-  mode: 'create' | 'edit';
-  initialData?: CreateItemFormData;
-  onSubmit: (data: CreateItemFormData) => Promise<void>;
-  /** 동적 폼 강제 사용 (테스트용) */
-  useDynamicForm?: boolean;
-  /** 특정 품목 유형으로 시작 (동적 폼에서 사용) */
-  defaultItemType?: ItemType;
-}
-
-/**
- * 동적 폼 사용 여부 결정
- */
-function shouldUseDynamicForm(
-  forceDynamic: boolean | undefined,
-  itemType: ItemType | undefined
-): boolean {
-  // 강제 동적 폼 사용
-  if (forceDynamic) return true;
-
-  // 전체 비활성화
-  if (!FEATURE_FLAGS.ENABLE_DYNAMIC_FORM) return false;
-
-  // 품목 유형별 활성화 체크
-  if (itemType && FEATURE_FLAGS.ENABLED_ITEM_TYPES.includes(itemType)) {
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * DynamicItemForm 데이터 → CreateItemFormData 변환
- */
-function transformDynamicToLegacy(
-  dynamicData: FormData,
-  itemType: ItemType
-): CreateItemFormData {
-  return {
-    itemType,
-    itemCode: String(dynamicData.item_code || ''),
-    itemName: String(dynamicData.item_name || ''),
-    unit: String(dynamicData.unit || 'EA'),
-    specification: dynamicData.specification ? String(dynamicData.specification) : undefined,
-    isActive: dynamicData.is_active !== false,
-    currentRevision: 0,
-    isFinal: false,
-    // 추가 필드들은 동적으로 매핑
-    productCategory: dynamicData.product_category ? String(dynamicData.product_category) : undefined,
-    partType: dynamicData.part_type ? String(dynamicData.part_type) : undefined,
-    material: dynamicData.material ? String(dynamicData.material) : undefined,
-    salesPrice: dynamicData.sales_price ? Number(dynamicData.sales_price) : undefined,
-    purchasePrice: dynamicData.purchase_price ? Number(dynamicData.purchase_price) : undefined,
-    marginRate: dynamicData.margin_rate ? Number(dynamicData.margin_rate) : undefined,
-    certificationNumber: dynamicData.certification_number ? String(dynamicData.certification_number) : undefined,
-    certificationStartDate: dynamicData.certification_start_date ? String(dynamicData.certification_start_date) : undefined,
-    certificationEndDate: dynamicData.certification_end_date ? String(dynamicData.certification_end_date) : undefined,
-  } as CreateItemFormData;
-}
-
-export default function ItemFormWrapper({
-  mode,
-  initialData,
-  onSubmit,
-  useDynamicForm: forceDynamic,
-  defaultItemType,
-}: ItemFormWrapperProps) {
-  // 현재 선택된 품목 유형 (동적 폼에서 변경 가능)
-  const [currentItemType, setCurrentItemType] = useState<ItemType>(
-    defaultItemType || initialData?.itemType || 'FG'
-  );
-
-  // 개발 모드에서 localStorage로 오버라이드 가능
-  const [localOverride, setLocalOverride] = useState<boolean | null>(null);
-
-  useEffect(() => {
-    if (typeof window !== 'undefined' && process.env.NODE_ENV === 'development') {
-      const override = localStorage.getItem('FORCE_DYNAMIC_FORM');
-      if (override !== null) {
-        setLocalOverride(override === 'true');
-      }
-    }
-  }, []);
-
-  // 동적 폼 사용 여부 결정
-  const useDynamic = localOverride !== null
-    ? localOverride
-    : shouldUseDynamicForm(forceDynamic, currentItemType);
-
-  // 동적 폼 제출 핸들러
-  const handleDynamicSubmit = async (dynamicData: FormData) => {
-    const legacyData = transformDynamicToLegacy(dynamicData, currentItemType);
-    await onSubmit(legacyData);
-  };
-
-  // 동적 폼 초기 데이터 변환
-  const dynamicInitialValues: FormData | undefined = initialData
-    ? {
-        item_code: initialData.itemCode,
-        item_name: initialData.itemName,
-        unit: initialData.unit,
-        specification: initialData.specification,
-        is_active: initialData.isActive,
-        product_category: initialData.productCategory,
-        part_type: initialData.partType,
-        material: initialData.material,
-        sales_price: initialData.salesPrice,
-        purchase_price: initialData.purchasePrice,
-        margin_rate: initialData.marginRate,
-        certification_number: initialData.certificationNumber,
-        certification_start_date: initialData.certificationStartDate,
-        certification_end_date: initialData.certificationEndDate,
-      }
-    : undefined;
-
-  // 개발 모드 토글 UI
-  const DevModeToggle = () => {
-    if (process.env.NODE_ENV !== 'development') return null;
-
-    return (
-      <div className="fixed bottom-4 right-4 z-50 bg-gray-900 text-white p-3 rounded-lg shadow-lg text-xs">
-        <div className="flex items-center gap-2 mb-2">
-          <span>🧪 폼 모드:</span>
-          <span className={useDynamic ? 'text-green-400' : 'text-yellow-400'}>
-            {useDynamic ? 'Dynamic' : 'Legacy'}
-          </span>
-        </div>
-        <button
-          type="button"
-          onClick={() => {
-            const newValue = !useDynamic;
-            localStorage.setItem('FORCE_DYNAMIC_FORM', String(newValue));
-            setLocalOverride(newValue);
-          }}
-          className="bg-blue-600 hover:bg-blue-700 px-2 py-1 rounded text-xs"
-        >
-          Toggle Form Mode
-        </button>
-      </div>
-    );
-  };
-
-  if (useDynamic) {
-    return (
-      <>
-        <DynamicItemForm
-          itemType={currentItemType}
-          initialValues={dynamicInitialValues}
-          onSubmit={handleDynamicSubmit}
-          onCancel={() => window.history.back()}
-          useMock={true} // API 구현 전까지 Mock 사용
-        />
-        <DevModeToggle />
-      </>
-    );
-  }
-
-  return (
-    <>
-      <ItemForm mode={mode} initialData={initialData} onSubmit={onSubmit} />
-      <DevModeToggle />
-    </>
-  );
-}
-
-// 개별 export
-export { ItemForm, DynamicItemForm };
\ No newline at end of file
diff --git a/src/components/items/ItemListClient.tsx b/src/components/items/ItemListClient.tsx
index e0080714..841b03ed 100644
--- a/src/components/items/ItemListClient.tsx
+++ b/src/components/items/ItemListClient.tsx
@@ -1,40 +1,51 @@
 /**
  * 품목 목록 Client Component
  *
- * Server Component에서 받은 데이터를 표시하고 상호작용 처리
+ * 품목기준관리 API 연동
+ * - 품목 목록: useItemList 훅으로 API 조회 (서버 사이드 검색/필터링)
+ * - IntegratedListTemplateV2 기반 공통 UI 적용
  */
 
 'use client';
 
-import { useState } from 'react';
+import { useState, useEffect, useRef } from 'react';
 import { useRouter } from 'next/navigation';
 import type { ItemMaster } from '@/types/item';
 import { ITEM_TYPE_LABELS } from '@/types/item';
 import { Button } from '@/components/ui/button';
-import { Input } from '@/components/ui/input';
-import {
-  Table,
-  TableBody,
-  TableCell,
-  TableHead,
-  TableHeader,
-  TableRow,
-} from '@/components/ui/table';
 import { Badge } from '@/components/ui/badge';
 import { Checkbox } from '@/components/ui/checkbox';
-import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
-import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
+import { TableRow, TableCell } from '@/components/ui/table';
 import {
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from '@/components/ui/select';
-import { Search, Plus, Edit, Trash2, Package, GitBranch, ChevronLeft, ChevronRight } from 'lucide-react';
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from '@/components/ui/alert-dialog';
+import { Search, Plus, Edit, Trash2, Package, Loader2 } from 'lucide-react';
+import { useItemList } from '@/hooks/useItemList';
+import {
+  IntegratedListTemplateV2,
+  type TabOption,
+  type TableColumn,
+  type StatCard,
+} from '@/components/templates/IntegratedListTemplateV2';
+import { ListMobileCard, InfoField } from '@/components/organisms/ListMobileCard';
 
-interface ItemListClientProps {
-  items: ItemMaster[];
+// Debounce 훅
+function useDebounce<T>(value: T, delay: number): T {
+  const [debouncedValue, setDebouncedValue] = useState<T>(value);
+
+  useEffect(() => {
+    const timer = setTimeout(() => setDebouncedValue(value), delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+
+  return debouncedValue;
 }
 
 /**
@@ -59,58 +70,82 @@ function getItemTypeBadge(itemType: string) {
 }
 
 /**
- * 조립품 품목코드 포맷팅 (하이픈 이후 제거)
+ * 부품 유형 라벨 반환
  */
-function formatItemCodeForAssembly(item: ItemMaster): string {
-  return item.itemCode;
+function getPartTypeLabel(partType: string | undefined): string {
+  if (!partType) return '';
+  const labels: Record<string, string> = {
+    ASSEMBLY: '조립',
+    BENDING: '절곡',
+    PURCHASED: '구매',
+  };
+  return labels[partType] || '';
 }
 
-export default function ItemListClient({ items: initialItems }: ItemListClientProps) {
+export default function ItemListClient() {
   const router = useRouter();
   const [searchTerm, setSearchTerm] = useState('');
   const [selectedType, setSelectedType] = useState<string>('all');
   const [selectedItems, setSelectedItems] = useState<Set<string>>(new Set());
-  const [selectAll, setSelectAll] = useState(false);
 
-  // 페이징 상태
-  const [currentPage, setCurrentPage] = useState(1);
-  const itemsPerPage = 20;
+  // 삭제 다이얼로그 상태
+  const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
+  const [itemToDelete, setItemToDelete] = useState<{ id: string; code: string } | null>(null);
 
-  // 필터링된 품목 목록
-  const filteredItems = initialItems.filter((item) => {
-    // 유형 필터
-    if (selectedType !== 'all' && item.itemType !== selectedType) {
-      return false;
+  // API에서 품목 목록 및 테이블 컬럼 조회 (서버 사이드 검색/필터링)
+  const {
+    items,
+    pagination,
+    totalStats,
+    isLoading,
+    isSearching,
+    refresh,
+    search,
+  } = useItemList();
+
+  // 디바운스된 검색어 (300ms 딜레이)
+  const debouncedSearchTerm = useDebounce(searchTerm, 300);
+
+  // 검색 상태 추적용 ref
+  const isFirstRender = useRef(true);
+
+  // 디바운스된 검색어 변경 시 서버 검색 실행
+  useEffect(() => {
+    // 첫 렌더링에서는 검색하지 않음
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+      return;
     }
 
-    // 검색어 필터
-    if (searchTerm) {
-      const search = searchTerm.toLowerCase();
-      return (
-        item.itemCode.toLowerCase().includes(search) ||
-        item.itemName.toLowerCase().includes(search) ||
-        item.specification?.toLowerCase().includes(search)
-      );
-    }
+    search({
+      search: debouncedSearchTerm,
+      type: selectedType,
+      page: 1,
+    });
+  }, [debouncedSearchTerm, selectedType, search]);
 
-    return true;
-  });
-
-  // 페이징 계산
-  const totalPages = Math.ceil(filteredItems.length / itemsPerPage);
-  const startIndex = (currentPage - 1) * itemsPerPage;
-  const endIndex = startIndex + itemsPerPage;
-  const paginatedItems = filteredItems.slice(startIndex, endIndex);
-
-  // 검색이나 필터 변경 시 첫 페이지로 이동
-  const handleSearchChange = (value: string) => {
-    setSearchTerm(value);
-    setCurrentPage(1);
-  };
+  // 로딩 상태
+  if (isLoading) {
+    return (
+      <div className="flex items-center justify-center py-12">
+        <Loader2 className="h-8 w-8 animate-spin text-primary" />
+        <span className="ml-3 text-muted-foreground">품목 목록 로딩 중...</span>
+      </div>
+    );
+  }
 
+  // 유형 변경 핸들러
   const handleTypeChange = (value: string) => {
     setSelectedType(value);
-    setCurrentPage(1);
+  };
+
+  // 페이지 변경 핸들러
+  const handlePageChange = (page: number) => {
+    search({
+      search: searchTerm,
+      type: selectedType,
+      page,
+    });
   };
 
   const handleView = (itemCode: string) => {
@@ -121,465 +156,355 @@ export default function ItemListClient({ items: initialItems }: ItemListClientPr
     router.push(`/items/${encodeURIComponent(itemCode)}/edit`);
   };
 
-  const handleDelete = async (itemCode: string) => {
-    if (!confirm(`품목 "${itemCode}"을(를) 삭제하시겠습니까?`)) {
-      return;
-    }
+  // 삭제 확인 다이얼로그 열기
+  const openDeleteDialog = (itemId: string, itemCode: string) => {
+    setItemToDelete({ id: itemId, code: itemCode });
+    setDeleteDialogOpen(true);
+  };
+
+  // 삭제 실행
+  const handleConfirmDelete = async () => {
+    if (!itemToDelete) return;
 
     try {
-      // TODO: API 연동 시 실제 삭제 로직 추가
-      // await deleteItem(itemCode);
-      alert('품목이 삭제되었습니다.');
-      router.refresh();
-    } catch {
-      alert('품목 삭제에 실패했습니다.');
+      console.log('[Delete] 삭제 요청:', itemToDelete);
+      const response = await fetch(`/api/proxy/items/${itemToDelete.id}`, {
+        method: 'DELETE',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+
+      const result = await response.json();
+      console.log('[Delete] 응답:', { status: response.status, result });
+
+      if (response.ok && result.success) {
+        alert('품목이 삭제되었습니다.');
+        refresh();
+      } else {
+        throw new Error(result.message || '삭제에 실패했습니다.');
+      }
+    } catch (error) {
+      console.error('품목 삭제 실패:', error);
+      alert(error instanceof Error ? error.message : '품목 삭제에 실패했습니다.');
+    } finally {
+      setDeleteDialogOpen(false);
+      setItemToDelete(null);
     }
   };
 
-  // 체크박스 전체 선택/해제 (현재 페이지만)
-  const handleSelectAll = () => {
-    if (selectAll) {
+  // 체크박스 전체 선택/해제
+  const toggleSelectAll = () => {
+    if (selectedItems.size === items.length && items.length > 0) {
       setSelectedItems(new Set());
-      setSelectAll(false);
     } else {
-      const allIds = new Set(paginatedItems.map((item) => item.id));
+      const allIds = new Set(items.map((item) => item.id));
       setSelectedItems(allIds);
-      setSelectAll(true);
     }
   };
 
   // 개별 체크박스 선택/해제
-  const handleSelectItem = (itemId: string) => {
+  const toggleSelection = (itemId: string) => {
     const newSelected = new Set(selectedItems);
     if (newSelected.has(itemId)) {
       newSelected.delete(itemId);
-      setSelectAll(false);
     } else {
       newSelected.add(itemId);
-      if (newSelected.size === paginatedItems.length) {
-        setSelectAll(true);
-      }
     }
     setSelectedItems(newSelected);
   };
 
-  // 통계 데이터
-  const stats = [
-    {
-      label: '전체 품목',
-      value: initialItems.length,
-      icon: Package,
-      iconColor: 'text-blue-600',
-    },
-    {
-      label: '제품',
-      value: initialItems.filter((i) => i.itemType === 'FG').length,
-      icon: Package,
-      iconColor: 'text-purple-600',
-    },
-    {
-      label: '부품',
-      value: initialItems.filter((i) => i.itemType === 'PT').length,
-      icon: Package,
-      iconColor: 'text-orange-600',
-    },
-    {
-      label: '부자재',
-      value: initialItems.filter((i) => i.itemType === 'SM').length,
-      icon: Package,
-      iconColor: 'text-green-600',
-    },
+  // 일괄 삭제 핸들러
+  const handleBulkDelete = async () => {
+    const itemIds = Array.from(selectedItems);
+    let successCount = 0;
+    let failCount = 0;
+
+    for (const id of itemIds) {
+      try {
+        const response = await fetch(`/api/proxy/items/${id}`, {
+          method: 'DELETE',
+          headers: { 'Content-Type': 'application/json' },
+        });
+        const result = await response.json();
+        if (response.ok && result.success) {
+          successCount++;
+        } else {
+          failCount++;
+        }
+      } catch {
+        failCount++;
+      }
+    }
+
+    if (successCount > 0) {
+      alert(`${successCount}개 품목이 삭제되었습니다.${failCount > 0 ? ` (${failCount}개 실패)` : ''}`);
+      setSelectedItems(new Set());
+      refresh();
+    } else {
+      alert('품목 삭제에 실패했습니다.');
+    }
+  };
+
+  // 탭 옵션 (품목 유형별)
+  const tabs: TabOption[] = [
+    { value: 'all', label: '전체', count: totalStats.totalAll, color: 'gray' },
+    { value: 'FG', label: '제품', count: totalStats.totalFG, color: 'purple' },
+    { value: 'PT', label: '부품', count: totalStats.totalPT, color: 'orange' },
+    { value: 'SM', label: '부자재', count: totalStats.totalSM, color: 'green' },
+    { value: 'RM', label: '원자재', count: totalStats.totalRM, color: 'blue' },
+    { value: 'CS', label: '소모품', count: totalStats.totalCS, color: 'gray' },
   ];
 
-  return (
-    <div className="space-y-6">
-      {/* 페이지 헤더 */}
-      <div className="flex flex-col md:flex-row md:items-center justify-between gap-4">
-        <div className="flex items-start gap-3">
-          <div className="p-2 bg-primary/10 rounded-lg hidden md:block">
-            <Package className="w-6 h-6 text-primary" />
-          </div>
-          <div>
-            <div className="flex items-center gap-2">
-              <h1 className="text-xl md:text-2xl">품목 관리</h1>
-              <Badge variant="secondary" className="gap-1">
-                <GitBranch className="h-3 w-3" />
-                v1.0.0
+  // 통계 카드 (전체 통계)
+  const stats: StatCard[] = [
+    { label: '전체 품목', value: totalStats.totalAll, icon: Package, iconColor: 'text-blue-600' },
+    { label: '제품', value: totalStats.totalFG, icon: Package, iconColor: 'text-purple-600' },
+    { label: '부품', value: totalStats.totalPT, icon: Package, iconColor: 'text-orange-600' },
+    { label: '부자재', value: totalStats.totalSM, icon: Package, iconColor: 'text-green-600' },
+    { label: '원자재', value: totalStats.totalRM, icon: Package, iconColor: 'text-cyan-600' },
+    { label: '소모품', value: totalStats.totalCS, icon: Package, iconColor: 'text-gray-600' },
+  ];
+
+  // 테이블 컬럼 정의
+  const tableColumns: TableColumn[] = [
+    { key: 'rowNumber', label: '번호', className: 'w-[60px] text-center' },
+    { key: 'itemCode', label: '품목코드', className: 'min-w-[120px]' },
+    { key: 'itemType', label: '품목유형', className: 'min-w-[100px]' },
+    { key: 'itemName', label: '품목명', className: 'min-w-[150px]' },
+    { key: 'specification', label: '규격', className: 'min-w-[100px]' },
+    { key: 'unit', label: '단위', className: 'min-w-[60px]' },
+    { key: 'status', label: '품목상태', className: 'min-w-[80px]' },
+    { key: 'actions', label: '작업', className: 'w-[120px] text-right' },
+  ];
+
+  // 테이블 행 렌더링
+  const renderTableRow = (item: ItemMaster, index: number, globalIndex: number) => {
+    const isSelected = selectedItems.has(item.id);
+
+    return (
+      <TableRow key={item.id} className="hover:bg-muted/50">
+        <TableCell className="text-center">
+          <Checkbox
+            checked={isSelected}
+            onCheckedChange={() => toggleSelection(item.id)}
+          />
+        </TableCell>
+        <TableCell className="text-muted-foreground text-center">
+          {globalIndex}
+        </TableCell>
+        <TableCell>
+          <code className="text-xs bg-gray-100 px-2 py-1 rounded">
+            {item.itemCode || '-'}
+          </code>
+        </TableCell>
+        <TableCell>
+          <div className="flex items-center gap-1 flex-wrap">
+            {getItemTypeBadge(item.itemType)}
+            {item.itemType === 'PT' && item.partType && (
+              <Badge variant="outline" className="bg-purple-50 text-purple-700 text-xs">
+                {getPartTypeLabel(item.partType)}
               </Badge>
-            </div>
-            <p className="text-sm text-muted-foreground mt-1">
-              제품, 부품, 부자재, 원자재, 소모품 등록 및 관리
-            </p>
+            )}
           </div>
-        </div>
-        <div className="flex gap-2 flex-wrap items-center">
-          <Button onClick={() => router.push('/items/create')}>
-            <Plus className="w-4 h-4 mr-2" />
-            품목 등록
-          </Button>
-        </div>
-      </div>
-
-      {/* 통계 카드 */}
-      <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">
-        {stats.map((stat, index) => (
-          <Card key={index}>
-            <CardContent className="p-4 md:p-6">
-              <div className="flex items-center justify-between">
-                <div>
-                  <p className="text-sm font-medium text-muted-foreground">
-                    {stat.label}
-                  </p>
-                  <p className="text-3xl md:text-4xl font-bold mt-2">{stat.value}</p>
-                </div>
-                <stat.icon className={`w-10 h-10 md:w-12 md:h-12 opacity-15 ${stat.iconColor}`} />
-              </div>
-            </CardContent>
-          </Card>
-        ))}
-      </div>
-
-      {/* 검색 및 필터 */}
-      <Card>
-        <CardContent className="p-4 md:p-6">
-          <div className="flex gap-4">
-            <div className="flex-1 relative">
-              <Search className="absolute left-3 top-1/2 -translate-y-1/2 w-4 h-4 text-muted-foreground" />
-              <Input
-                placeholder="품목코드, 품목명, 규격 검색..."
-                value={searchTerm}
-                onChange={(e) => handleSearchChange(e.target.value)}
-                className="pl-10"
-              />
-            </div>
-            <Select value={selectedType} onValueChange={handleTypeChange}>
-              <SelectTrigger className="w-[180px]">
-                <SelectValue placeholder="품목 유형" />
-              </SelectTrigger>
-              <SelectContent>
-                <SelectItem value="all">
-                  전체 ({initialItems.length})
-                </SelectItem>
-                <SelectItem value="FG">
-                  제품 ({initialItems.filter((i) => i.itemType === 'FG').length})
-                </SelectItem>
-                <SelectItem value="PT">
-                  부품 ({initialItems.filter((i) => i.itemType === 'PT').length})
-                </SelectItem>
-                <SelectItem value="SM">
-                  부자재 ({initialItems.filter((i) => i.itemType === 'SM').length})
-                </SelectItem>
-                <SelectItem value="RM">
-                  원자재 ({initialItems.filter((i) => i.itemType === 'RM').length})
-                </SelectItem>
-                <SelectItem value="CS">
-                  소모품 ({initialItems.filter((i) => i.itemType === 'CS').length})
-                </SelectItem>
-              </SelectContent>
-            </Select>
+        </TableCell>
+        <TableCell>
+          <span className="truncate max-w-[200px] block">
+            {item.itemName}
+          </span>
+        </TableCell>
+        <TableCell className="text-muted-foreground">
+          {item.specification || '-'}
+        </TableCell>
+        <TableCell>
+          <Badge variant="secondary">{item.unit || '-'}</Badge>
+        </TableCell>
+        <TableCell>
+          <Badge variant={item.isActive ? 'default' : 'secondary'}>
+            {item.isActive ? '활성' : '비활성'}
+          </Badge>
+        </TableCell>
+        <TableCell className="text-right">
+          <div className="flex items-center justify-end gap-1">
+            <Button
+              variant="ghost"
+              size="sm"
+              onClick={() => handleView(item.itemCode)}
+              title="상세 보기"
+            >
+              <Search className="w-4 h-4" />
+            </Button>
+            <Button
+              variant="ghost"
+              size="sm"
+              onClick={() => handleEdit(item.itemCode)}
+              title="수정"
+            >
+              <Edit className="w-4 h-4" />
+            </Button>
+            <Button
+              variant="ghost"
+              size="sm"
+              onClick={() => openDeleteDialog(item.id, item.itemCode)}
+              title="삭제"
+            >
+              <Trash2 className="w-4 h-4 text-red-500" />
+            </Button>
           </div>
-        </CardContent>
-      </Card>
+        </TableCell>
+      </TableRow>
+    );
+  };
 
-      {/* 품목 목록 - 탭과 테이블 */}
-      <Card>
-        <CardHeader>
-          <CardTitle className="text-sm md:text-base">
-            {selectedType === 'all'
-              ? `전체 목록 (${filteredItems.length}개)`
-              : `${ITEM_TYPE_LABELS[selectedType as keyof typeof ITEM_TYPE_LABELS]} 목록 (${filteredItems.length}개)`
-            }
-          </CardTitle>
-        </CardHeader>
-        <CardContent className="p-4 md:p-6">
-          <Tabs value={selectedType} onValueChange={handleTypeChange} className="w-full">
-            <div className="overflow-x-auto -mx-2 px-2 mb-6">
-              <TabsList className="inline-flex w-auto min-w-full md:grid md:w-full md:max-w-2xl md:grid-cols-6">
-                <TabsTrigger value="all" className="whitespace-nowrap">
-                  전체 ({initialItems.length})
-                </TabsTrigger>
-                <TabsTrigger value="FG" className="whitespace-nowrap">
-                  제품 ({initialItems.filter((i) => i.itemType === 'FG').length})
-                </TabsTrigger>
-                <TabsTrigger value="PT" className="whitespace-nowrap">
-                  부품 ({initialItems.filter((i) => i.itemType === 'PT').length})
-                </TabsTrigger>
-                <TabsTrigger value="SM" className="whitespace-nowrap">
-                  부자재 ({initialItems.filter((i) => i.itemType === 'SM').length})
-                </TabsTrigger>
-                <TabsTrigger value="RM" className="whitespace-nowrap">
-                  원자재 ({initialItems.filter((i) => i.itemType === 'RM').length})
-                </TabsTrigger>
-                <TabsTrigger value="CS" className="whitespace-nowrap">
-                  소모품 ({initialItems.filter((i) => i.itemType === 'CS').length})
-                </TabsTrigger>
-              </TabsList>
-            </div>
+  // 모바일 카드 렌더링
+  const renderMobileCard = (
+    item: ItemMaster,
+    index: number,
+    globalIndex: number,
+    isSelected: boolean,
+    onToggle: () => void
+  ) => {
+    return (
+      <ListMobileCard
+        id={item.id}
+        title={item.itemName}
+        headerBadges={
+          <div className="flex items-center gap-2 flex-wrap">
+            <code className="text-xs bg-gray-100 px-2 py-1 rounded">
+              {item.itemCode}
+            </code>
+            {getItemTypeBadge(item.itemType)}
+            {item.itemType === 'PT' && item.partType && (
+              <Badge variant="outline" className="bg-purple-50 text-purple-700 text-xs">
+                {getPartTypeLabel(item.partType)}
+              </Badge>
+            )}
+          </div>
+        }
+        statusBadge={
+          <Badge variant={item.isActive ? 'default' : 'secondary'}>
+            {item.isActive ? '활성' : '비활성'}
+          </Badge>
+        }
+        isSelected={isSelected}
+        onToggleSelection={onToggle}
+        onCardClick={() => handleView(item.itemCode)}
+        infoGrid={
+          <div className="grid grid-cols-2 gap-x-4 gap-y-3">
+            {item.specification && (
+              <InfoField label="규격" value={item.specification} />
+            )}
+            {item.unit && (
+              <InfoField label="단위" value={item.unit} />
+            )}
+          </div>
+        }
+        actions={
+          <div className="flex items-center justify-end gap-1 pt-2">
+            <Button
+              variant="ghost"
+              size="sm"
+              onClick={(e) => { e.stopPropagation(); handleView(item.itemCode); }}
+              className="h-8 px-3"
+            >
+              <Search className="h-4 w-4 mr-1" />
+              <span className="text-xs">상세</span>
+            </Button>
+            <Button
+              variant="ghost"
+              size="sm"
+              onClick={(e) => { e.stopPropagation(); handleEdit(item.itemCode); }}
+              className="h-8 px-3"
+            >
+              <Edit className="h-4 w-4 mr-1" />
+              <span className="text-xs">수정</span>
+            </Button>
+            <Button
+              variant="ghost"
+              size="sm"
+              onClick={(e) => { e.stopPropagation(); openDeleteDialog(item.id, item.itemCode); }}
+              className="h-8 px-2"
+            >
+              <Trash2 className="h-4 w-4 text-red-600" />
+            </Button>
+          </div>
+        }
+      />
+    );
+  };
 
-            <TabsContent value={selectedType} className="mt-0">
-              {/* 모바일 카드 뷰 */}
-              <div className="lg:hidden space-y-3">
-                {paginatedItems.length === 0 ? (
-                  <div className="text-center py-8 text-muted-foreground border rounded-lg">
-                    {searchTerm || selectedType !== 'all'
-                      ? '검색 결과가 없습니다.'
-                      : '등록된 품목이 없습니다.'}
-                  </div>
-                ) : (
-                  paginatedItems.map((item, index) => (
-                    <div
-                      key={`${item.id}-mobile-${index}`}
-                      className="border rounded-lg p-4 space-y-3 bg-card hover:bg-muted/50 transition-colors"
-                    >
-                      <div className="flex items-start justify-between gap-3">
-                        <div className="flex items-start gap-3 flex-1 min-w-0">
-                          <Checkbox
-                            checked={selectedItems.has(item.id)}
-                            onCheckedChange={() => handleSelectItem(item.id)}
-                            onClick={(e) => e.stopPropagation()}
-                          />
-                          <div className="flex-1 min-w-0 space-y-2">
-                            <div className="flex items-center gap-2 flex-wrap">
-                              <code className="text-xs bg-gray-100 px-2 py-1 rounded">
-                                {formatItemCodeForAssembly(item)}
-                              </code>
-                              {getItemTypeBadge(item.itemType)}
-                              {item.itemType === 'PT' && item.partType && (
-                                <Badge variant="outline" className="ml-1 bg-purple-50 text-purple-700 text-xs">
-                                  {item.partType === 'ASSEMBLY' ? '조립' :
-                                   item.partType === 'BENDING' ? '절곡' :
-                                   item.partType === 'PURCHASED' ? '구매' : ''}
-                                </Badge>
-                              )}
-                            </div>
-                            <div
-                              className="font-medium cursor-pointer"
-                              onClick={() => handleView(item.itemCode)}
-                            >
-                              {item.itemName}
-                            </div>
-                            {(item.specification || (item.itemCode?.includes('-') && item.itemCode.split('-').slice(1).join('-'))) && (
-                              <div className="text-sm text-muted-foreground">
-                                규격: {item.itemCode?.includes('-')
-                                  ? item.itemCode.split('-').slice(1).join('-')
-                                  : item.specification}
-                              </div>
-                            )}
-                            {item.unit && (
-                              <div>
-                                <Badge variant="secondary" className="text-xs">{item.unit}</Badge>
-                              </div>
-                            )}
-                          </div>
-                        </div>
-                      </div>
-                      <div className="flex items-center justify-end gap-1 pt-2 border-t">
-                        <Button
-                          variant="ghost"
-                          size="sm"
-                          onClick={() => handleView(item.itemCode)}
-                          className="h-8 px-3"
-                        >
-                          <Search className="h-4 w-4 mr-1" />
-                          <span className="text-xs">상세</span>
-                        </Button>
-                        <Button
-                          variant="ghost"
-                          size="sm"
-                          onClick={() => handleEdit(item.itemCode)}
-                          className="h-8 px-3"
-                        >
-                          <Edit className="h-4 w-4 mr-1" />
-                          <span className="text-xs">수정</span>
-                        </Button>
-                        <Button
-                          variant="ghost"
-                          size="sm"
-                          onClick={() => handleDelete(item.itemCode)}
-                          className="h-8 px-2"
-                        >
-                          <Trash2 className="h-4 w-4 text-red-600" />
-                        </Button>
-                      </div>
-                    </div>
-                  ))
-                )}
-              </div>
-
-              {/* 데스크톱 테이블 */}
-              <div className="hidden lg:block rounded-md border">
-                <Table>
-                  <TableHeader>
-                    <TableRow>
-                      <TableHead className="w-[50px]">
-                        <Checkbox
-                          checked={selectAll}
-                          onCheckedChange={handleSelectAll}
-                        />
-                      </TableHead>
-                      <TableHead className="hidden md:table-cell">번호</TableHead>
-                      <TableHead className="min-w-[100px]">품목코드</TableHead>
-                      <TableHead className="min-w-[80px]">품목유형</TableHead>
-                      <TableHead className="min-w-[120px]">품목명</TableHead>
-                      <TableHead className="hidden md:table-cell">규격</TableHead>
-                      <TableHead className="hidden md:table-cell">단위</TableHead>
-                      <TableHead className="min-w-[100px] whitespace-nowrap">품목 상태</TableHead>
-                      <TableHead className="text-right min-w-[100px]">작업</TableHead>
-                    </TableRow>
-                  </TableHeader>
-                  <TableBody>
-                    {paginatedItems.length === 0 ? (
-                      <TableRow>
-                        <TableCell colSpan={9} className="text-center py-8 text-gray-500">
-                          {searchTerm || selectedType !== 'all'
-                            ? '검색 결과가 없습니다.'
-                            : '등록된 품목이 없습니다.'}
-                        </TableCell>
-                      </TableRow>
-                    ) : (
-                      paginatedItems.map((item, index) => (
-                        <TableRow key={item.id} className="hover:bg-gray-50">
-                          <TableCell>
-                            <Checkbox
-                              checked={selectedItems.has(item.id)}
-                              onCheckedChange={() => handleSelectItem(item.id)}
-                            />
-                          </TableCell>
-                          <TableCell className="text-muted-foreground cursor-pointer hidden md:table-cell">
-                            {filteredItems.length - (startIndex + index)}
-                          </TableCell>
-                          <TableCell className="cursor-pointer">
-                            <code className="text-xs bg-gray-100 px-2 py-1 rounded">
-                              {formatItemCodeForAssembly(item) || '-'}
-                            </code>
-                          </TableCell>
-                          <TableCell className="cursor-pointer">
-                            {getItemTypeBadge(item.itemType)}
-                            {item.itemType === 'PT' && item.partType && (
-                              <Badge variant="outline" className="ml-1 bg-purple-50 text-purple-700 text-xs hidden lg:inline-flex">
-                                {item.partType === 'ASSEMBLY' ? '조립' :
-                                 item.partType === 'BENDING' ? '절곡' :
-                                 item.partType === 'PURCHASED' ? '구매' : ''}
-                              </Badge>
-                            )}
-                          </TableCell>
-                          <TableCell className="cursor-pointer">
-                            <div className="flex items-center gap-2">
-                              <span className="truncate max-w-[150px] md:max-w-none">
-                                {item.itemName}
-                              </span>
-                            </div>
-                          </TableCell>
-                          <TableCell className="text-sm text-muted-foreground cursor-pointer hidden md:table-cell">
-                            {item.itemCode?.includes('-')
-                              ? item.itemCode.split('-').slice(1).join('-')
-                              : item.specification || '-'}
-                          </TableCell>
-                          <TableCell className="cursor-pointer hidden md:table-cell">
-                            <Badge variant="secondary">{item.unit || '-'}</Badge>
-                          </TableCell>
-                          <TableCell className="whitespace-nowrap">
-                            <Badge variant={item.isActive ? 'default' : 'secondary'}>
-                              {item.isActive ? '활성' : '비활성'}
-                            </Badge>
-                          </TableCell>
-                          <TableCell className="text-right">
-                            <div className="flex items-center justify-end gap-1">
-                              <Button
-                                variant="ghost"
-                                size="sm"
-                                onClick={() => handleView(item.itemCode)}
-                                title="상세 보기"
-                              >
-                                <Search className="w-4 h-4" />
-                              </Button>
-                              <Button
-                                variant="ghost"
-                                size="sm"
-                                onClick={() => handleEdit(item.itemCode)}
-                                title="수정"
-                              >
-                                <Edit className="w-4 h-4" />
-                              </Button>
-                              <Button
-                                variant="ghost"
-                                size="sm"
-                                onClick={() => handleDelete(item.itemCode)}
-                                title="삭제"
-                              >
-                                <Trash2 className="w-4 h-4 text-red-500" />
-                              </Button>
-                            </div>
-                          </TableCell>
-                        </TableRow>
-                      ))
-                    )}
-                  </TableBody>
-                </Table>
-              </div>
-
-              {/* 페이지네이션 */}
-              {filteredItems.length > 0 && (
-                <div className="flex flex-col sm:flex-row items-center justify-between gap-4 mt-4">
-                  <div className="text-sm text-muted-foreground">
-                    전체 {filteredItems.length}개 중 {startIndex + 1}-{Math.min(endIndex, filteredItems.length)}개 표시
-                  </div>
-                  <div className="flex items-center gap-2">
-                    <Button
-                      variant="outline"
-                      size="sm"
-                      onClick={() => setCurrentPage(currentPage - 1)}
-                      disabled={currentPage === 1}
-                    >
-                      <ChevronLeft className="w-4 h-4" />
-                      이전
-                    </Button>
-                    <div className="flex items-center gap-1">
-                      {Array.from({ length: totalPages }, (_, i) => i + 1)
-                        .filter((page) => {
-                          // 현재 페이지 주변 5개만 표시
-                          return (
-                            page === 1 ||
-                            page === totalPages ||
-                            (page >= currentPage - 2 && page <= currentPage + 2)
-                          );
-                        })
-                        .map((page, index, array) => {
-                          // 페이지 번호 사이에 ... 표시
-                          const showEllipsisBefore = index > 0 && array[index - 1] !== page - 1;
-                          return (
-                            <div key={page} className="flex items-center gap-1">
-                              {showEllipsisBefore && (
-                                <span className="px-2 text-muted-foreground">...</span>
-                              )}
-                              <Button
-                                variant={currentPage === page ? 'default' : 'outline'}
-                                size="sm"
-                                onClick={() => setCurrentPage(page)}
-                                className="w-8 h-8 p-0"
-                              >
-                                {page}
-                              </Button>
-                            </div>
-                          );
-                        })}
-                    </div>
-                    <Button
-                      variant="outline"
-                      size="sm"
-                      onClick={() => setCurrentPage(currentPage + 1)}
-                      disabled={currentPage === totalPages}
-                    >
-                      다음
-                      <ChevronRight className="w-4 h-4" />
-                    </Button>
-                  </div>
-                </div>
-              )}
-            </TabsContent>
-          </Tabs>
-        </CardContent>
-      </Card>
+  // 헤더 액션 (검색 중 로딩 + 품목 등록 버튼)
+  const headerActions = (
+    <div className="flex items-center gap-2">
+      {isSearching && (
+        <div className="flex items-center gap-2 text-muted-foreground">
+          <Loader2 className="h-4 w-4 animate-spin" />
+          <span className="text-sm hidden sm:inline">검색 중...</span>
+        </div>
+      )}
+      <Button onClick={() => router.push('/items/create')}>
+        <Plus className="w-4 h-4 mr-2" />
+        품목 등록
+      </Button>
     </div>
   );
+
+  return (
+    <>
+      <IntegratedListTemplateV2<ItemMaster>
+        title="품목 관리"
+        description="제품, 부품, 부자재, 원자재, 소모품 등록 및 관리"
+        icon={Package}
+        headerActions={headerActions}
+        stats={stats}
+        searchValue={searchTerm}
+        onSearchChange={setSearchTerm}
+        searchPlaceholder="품목코드, 품목명, 규격 검색..."
+        tabs={tabs}
+        activeTab={selectedType}
+        onTabChange={handleTypeChange}
+        tableColumns={tableColumns}
+        data={items}
+        totalCount={pagination.totalItems}
+        allData={items}
+        selectedItems={selectedItems}
+        onToggleSelection={toggleSelection}
+        onToggleSelectAll={toggleSelectAll}
+        onBulkDelete={handleBulkDelete}
+        getItemId={(item) => item.id}
+        renderTableRow={renderTableRow}
+        renderMobileCard={renderMobileCard}
+        pagination={{
+          currentPage: pagination.currentPage,
+          totalPages: pagination.totalPages,
+          totalItems: pagination.totalItems,
+          itemsPerPage: pagination.perPage,
+          onPageChange: handlePageChange,
+        }}
+      />
+
+      {/* 개별 삭제 확인 다이얼로그 */}
+      <AlertDialog open={deleteDialogOpen} onOpenChange={setDeleteDialogOpen}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>품목 삭제</AlertDialogTitle>
+            <AlertDialogDescription>
+              품목 &quot;{itemToDelete?.code}&quot;을(를) 삭제하시겠습니까?
+              <br />
+              이 작업은 되돌릴 수 없습니다.
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>취소</AlertDialogCancel>
+            <AlertDialogAction
+              onClick={handleConfirmDelete}
+              className="bg-red-600 hover:bg-red-700"
+            >
+              삭제
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </>
+  );
 }
\ No newline at end of file
diff --git a/src/components/items/ItemMasterDataManagement.tsx b/src/components/items/ItemMasterDataManagement.tsx
index 54825e9a..f49f26e0 100644
--- a/src/components/items/ItemMasterDataManagement.tsx
+++ b/src/components/items/ItemMasterDataManagement.tsx
@@ -123,24 +123,6 @@ export function ItemMasterDataManagement() {
     deleteBOMItem,
   } = useItemMaster();
 
-  console.log('ItemMasterDataManagement: Current sectionTemplates', sectionTemplates);
-
-  // 2025-11-27: itemPages 변화 추적 (디버깅용)
-  useEffect(() => {
-    console.log('[ItemMasterDataManagement] ⚡ itemPages changed:', {
-      pageCount: itemPages.length,
-      pages: itemPages.map(p => ({
-        id: p.id,
-        name: p.page_name,
-        sectionsCount: p.sections.length,
-        sections: p.sections.map(s => ({
-          id: s.id,
-          title: s.title,
-          fieldsCount: s.fields?.length || 0
-        }))
-      }))
-    });
-  }, [itemPages]);
 
   // ===== 커스텀 훅 초기화 =====
   const pageManagement = usePageManagement();
@@ -314,11 +296,6 @@ export function ItemMasterDataManagement() {
   // 이렇게 하면 계층구조 탭과 섹션 탭이 같은 데이터 소스를 사용하여 자동 동기화됨
   // 독립 섹션: 페이지에서 연결 해제된 섹션 (page_id = null)
   const sectionsAsTemplates: SectionTemplate[] = useMemo(() => {
-    console.log('[sectionsAsTemplates] useMemo 재계산! itemPages:', itemPages.map(p => ({
-      id: p.id,
-      sections: p.sections.map(s => ({ id: s.id, fieldsCount: s.fields?.length || 0 }))
-    })));
-
     // 1. itemPages에 연결된 섹션들
     const linkedSections = itemPages.flatMap(page =>
       page.sections.map(section => ({
@@ -400,18 +377,6 @@ export function ItemMasterDataManagement() {
     return uniqueSections;
   }, [itemPages, independentSections]);
 
-  // 2025-11-27: sectionsAsTemplates 변화 추적 (디버깅용)
-  useEffect(() => {
-    console.log('[ItemMasterDataManagement] 📋 sectionsAsTemplates changed:', {
-      count: sectionsAsTemplates.length,
-      sections: sectionsAsTemplates.map(s => ({
-        id: s.id,
-        name: s.template_name,
-        fieldsCount: s.fields?.length || 0
-      }))
-    });
-  }, [sectionsAsTemplates]);
-
   // 마운트 상태 추적 (SSR 호환)
   const [_mounted, setMounted] = useState(false);
 
@@ -582,8 +547,13 @@ export function ItemMasterDataManagement() {
     if (!importFieldTargetSectionId || !selectedImportFieldId) return;
 
     try {
+      // 2025-12-02: 섹션별 순서 종속 - 해당 섹션의 마지막 순서 + 1로 설정
+      const targetSection = selectedPage?.sections.find(s => s.id === importFieldTargetSectionId);
+      const existingFieldsCount = targetSection?.fields?.length ?? 0;
+      const newOrderNo = existingFieldsCount; // 0-based로 마지막 다음 순서
+
       // 2025-11-27: 통합된 필드 연결 방식
-      await linkFieldToSection(importFieldTargetSectionId, selectedImportFieldId);
+      await linkFieldToSection(importFieldTargetSectionId, selectedImportFieldId, newOrderNo);
       toast.success('필드를 섹션에 연결했습니다.');
 
       setSelectedImportFieldId(null);
@@ -704,15 +674,37 @@ export function ItemMasterDataManagement() {
   };
 
   // 필드 순서 변경 핸들러
-  const moveField = (sectionId: number, dragIndex: number, hoverIndex: number) => {
+  // 2025-12-03: ID 기반으로 변경 (index stale 문제 해결)
+  const moveField = async (sectionId: number, dragFieldId: number, hoverFieldId: number) => {
     if (!selectedPage) return;
     const section = selectedPage.sections.find(s => s.id === sectionId);
     if (!section || !section.fields) return;
-    const newFields = [...section.fields];
-    const [draggedField] = newFields.splice(dragIndex, 1);
-    newFields.splice(hoverIndex, 0, draggedField);
-    reorderFields(sectionId, newFields.map(f => f.id));
-    // hasUnsavedChanges는 computed value이므로 자동 계산됨
+
+    // 동일 필드면 스킵
+    if (dragFieldId === hoverFieldId) return;
+
+    // 정렬된 배열에서 ID로 인덱스 찾기
+    const sortedFields = [...section.fields].sort((a, b) => (a.order_no ?? 0) - (b.order_no ?? 0));
+    const dragIndex = sortedFields.findIndex(f => f.id === dragFieldId);
+    const hoverIndex = sortedFields.findIndex(f => f.id === hoverFieldId);
+
+    // 유효하지 않은 인덱스 체크
+    if (dragIndex === -1 || hoverIndex === -1) {
+      return;
+    }
+
+    // 드래그된 필드를 제거하고 새 위치에 삽입
+    const [draggedField] = sortedFields.splice(dragIndex, 1);
+    sortedFields.splice(hoverIndex, 0, draggedField);
+
+    const newFieldIds = sortedFields.map(f => f.id);
+
+    try {
+      await reorderFields(sectionId, newFieldIds);
+      toast.success('항목 순서가 변경되었습니다');
+    } catch (error) {
+      toast.error('항목 순서 변경에 실패했습니다');
+    }
   };
 
   // 전체 데이터 초기화 핸들러
diff --git a/src/components/items/ItemMasterDataManagement/components/ConditionalDisplayUI.tsx b/src/components/items/ItemMasterDataManagement/components/ConditionalDisplayUI.tsx
index e96650ef..8fc5a0e9 100644
--- a/src/components/items/ItemMasterDataManagement/components/ConditionalDisplayUI.tsx
+++ b/src/components/items/ItemMasterDataManagement/components/ConditionalDisplayUI.tsx
@@ -95,7 +95,8 @@ export function ConditionalDisplayUI({
   // 신규 ItemField 타입: id는 number
   const availableFields = selectedSectionForField?.fields?.filter(f => f.id !== editingFieldId) || [];
   // 신규 ItemSection 타입: section_type은 'BASIC' | 'BOM' | 'CUSTOM'
-  const availableSections = selectedPage?.sections.filter(s => s.section_type !== 'BOM') || [];
+  // 2025-12-03: BOM 섹션도 조건부 표시 대상으로 포함 (체크박스 → BOM 섹션 연결용)
+  const availableSections = selectedPage?.sections || [];
 
   return (
     <div className="border-t pt-4 space-y-3">
diff --git a/src/components/items/ItemMasterDataManagement/components/DraggableField.tsx b/src/components/items/ItemMasterDataManagement/components/DraggableField.tsx
index b646dcf6..7b706020 100644
--- a/src/components/items/ItemMasterDataManagement/components/DraggableField.tsx
+++ b/src/components/items/ItemMasterDataManagement/components/DraggableField.tsx
@@ -21,7 +21,8 @@ const INPUT_TYPE_OPTIONS = [
 interface DraggableFieldProps {
   field: ItemField;
   index: number;
-  moveField: (dragIndex: number, hoverIndex: number) => void;
+  // 2025-12-03: ID 기반으로 변경 (index는 stale 문제 발생)
+  moveField: (dragFieldId: number, hoverFieldId: number) => void;
   onDelete: () => void;
   onEdit?: () => void;
 }
@@ -30,8 +31,10 @@ export function DraggableField({ field, index, moveField, onDelete, onEdit }: Dr
   const [isDragging, setIsDragging] = useState(false);
 
   const handleDragStart = (e: React.DragEvent) => {
+    e.stopPropagation(); // 2025-12-03: 섹션 드래그 이벤트와 충돌 방지
     e.dataTransfer.effectAllowed = 'move';
-    e.dataTransfer.setData('text/plain', JSON.stringify({ index, id: field.id }));
+    // 2025-12-03: 타입 구분 추가 (섹션/필드 드래그 구분)
+    e.dataTransfer.setData('application/json', JSON.stringify({ type: 'field', id: field.id }));
     setIsDragging(true);
   };
 
@@ -41,18 +44,25 @@ export function DraggableField({ field, index, moveField, onDelete, onEdit }: Dr
 
   const handleDragOver = (e: React.DragEvent) => {
     e.preventDefault();
+    e.stopPropagation(); // 2025-12-03: 이벤트 버블링 방지
     e.dataTransfer.dropEffect = 'move';
   };
 
   const handleDrop = (e: React.DragEvent) => {
     e.preventDefault();
+    e.stopPropagation(); // 2025-12-03: 이벤트 버블링 방지
     try {
-      const data = JSON.parse(e.dataTransfer.getData('text/plain'));
-      if (data.index !== index) {
-        moveField(data.index, index);
+      const data = JSON.parse(e.dataTransfer.getData('application/json'));
+      // 2025-12-03: 타입 체크 - 필드 드래그만 처리
+      if (data.type !== 'field') {
+        console.log('[DraggableField] 필드 드래그가 아님, 무시:', data);
+        return;
+      }
+      if (data.id !== field.id) {
+        moveField(data.id, field.id);
       }
     } catch (err) {
-      // Ignore
+      // Ignore - 다른 타입의 드래그 데이터
     }
   };
 
diff --git a/src/components/items/ItemMasterDataManagement/components/DraggableSection.tsx b/src/components/items/ItemMasterDataManagement/components/DraggableSection.tsx
index 1e69c26e..0e2171f9 100644
--- a/src/components/items/ItemMasterDataManagement/components/DraggableSection.tsx
+++ b/src/components/items/ItemMasterDataManagement/components/DraggableSection.tsx
@@ -42,7 +42,8 @@ export function DraggableSection({
 
   const handleDragStart = (e: React.DragEvent) => {
     e.dataTransfer.effectAllowed = 'move';
-    e.dataTransfer.setData('text/plain', JSON.stringify({ index, id: section.id }));
+    // 2025-12-03: 타입 구분 추가 (섹션/필드 드래그 구분)
+    e.dataTransfer.setData('application/json', JSON.stringify({ type: 'section', index, id: section.id }));
     setIsDragging(true);
   };
 
@@ -58,12 +59,16 @@ export function DraggableSection({
   const handleDrop = (e: React.DragEvent) => {
     e.preventDefault();
     try {
-      const data = JSON.parse(e.dataTransfer.getData('text/plain'));
+      const data = JSON.parse(e.dataTransfer.getData('application/json'));
+      // 2025-12-03: 타입 체크 - 섹션 드래그만 처리
+      if (data.type !== 'section') {
+        return;
+      }
       if (data.index !== index) {
         moveSection(data.index, index);
       }
     } catch (err) {
-      // Ignore
+      // Ignore - 다른 타입의 드래그 데이터
     }
   };
 
diff --git a/src/components/items/ItemMasterDataManagement/dialogs/PageDialog.tsx b/src/components/items/ItemMasterDataManagement/dialogs/PageDialog.tsx
index bf7d412c..41f0110a 100644
--- a/src/components/items/ItemMasterDataManagement/dialogs/PageDialog.tsx
+++ b/src/components/items/ItemMasterDataManagement/dialogs/PageDialog.tsx
@@ -10,7 +10,7 @@ import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@
 const ITEM_TYPE_OPTIONS = [
   { value: 'FG', label: '제품 (FG)' },
   { value: 'PT', label: '부품 (PT)' },
-  { value: 'SM', label: '반제품 (SM)' },
+  { value: 'SM', label: '부자재 (SM)' },
   { value: 'RM', label: '원자재 (RM)' },
   { value: 'CS', label: '소모품 (CS)' },
 ];
diff --git a/src/components/items/ItemMasterDataManagement/hooks/useFieldManagement.ts b/src/components/items/ItemMasterDataManagement/hooks/useFieldManagement.ts
index 66373ec7..8ac8f950 100644
--- a/src/components/items/ItemMasterDataManagement/hooks/useFieldManagement.ts
+++ b/src/components/items/ItemMasterDataManagement/hooks/useFieldManagement.ts
@@ -145,15 +145,15 @@ export function useFieldManagement(): UseFieldManagementReturn {
     }
 
     // 조건부 표시 설정
+    // 2025-12-02: ConditionalDisplayUI는 field/section 모두 newFieldConditionFields에 저장
+    // - field 모드: fieldConditions[].targetFieldIds에 필드 ID 저장
+    // - section 모드: fieldConditions[].targetSectionIds에 섹션 ID 저장
     const displayCondition: FieldDisplayCondition | undefined = newFieldConditionEnabled
       ? {
           targetType: newFieldConditionTargetType,
-          fieldConditions: newFieldConditionTargetType === 'field' && newFieldConditionFields.length > 0
+          fieldConditions: newFieldConditionFields.length > 0
             ? newFieldConditionFields
             : undefined,
-          sectionIds: newFieldConditionTargetType === 'section' && newFieldConditionSections.length > 0
-            ? newFieldConditionSections
-            : undefined
         }
       : undefined;
 
diff --git a/src/components/items/ItemMasterDataManagement/tabs/HierarchyTab/index.tsx b/src/components/items/ItemMasterDataManagement/tabs/HierarchyTab/index.tsx
index 9bcac64b..d97595f5 100644
--- a/src/components/items/ItemMasterDataManagement/tabs/HierarchyTab/index.tsx
+++ b/src/components/items/ItemMasterDataManagement/tabs/HierarchyTab/index.tsx
@@ -59,7 +59,8 @@ interface HierarchyTabProps {
   updateSection: (sectionId: number, updates: Partial<ItemSection>) => Promise<void>;
   deleteField: (pageId: string, sectionId: string, fieldId: string) => void;  // 2025-11-27: 연결 해제로 변경 (삭제 아님, 항목 탭에 유지)
   handleEditField: (sectionId: string, field: any) => void;
-  moveField: (sectionId: number, dragIndex: number, hoverIndex: number) => void;
+  // 2025-12-03: ID 기반으로 변경 (index stale 문제 해결)
+  moveField: (sectionId: number, dragFieldId: number, hoverFieldId: number) => void | Promise<void>;
   // 2025-11-26 추가: 섹션/필드 불러오기
   setIsImportSectionDialogOpen?: (open: boolean) => void;
   setIsImportFieldDialogOpen?: (open: boolean) => void;
@@ -441,10 +442,10 @@ export function HierarchyTab({
                                 .sort((a, b) => (a.order_no ?? 0) - (b.order_no ?? 0))
                                 .map((field, fieldIndex) => (
                                   <DraggableField
-                                    key={`field-${field.id}-${fieldIndex}`}
+                                    key={field.id}
                                     field={field}
                                     index={fieldIndex}
-                                    moveField={(dragIndex, hoverIndex) => moveField(section.id, dragIndex, hoverIndex)}
+                                    moveField={(dragFieldId, hoverFieldId) => moveField(section.id, dragFieldId, hoverFieldId)}
                                     onDelete={() => {
                                       if (confirm('이 항목을 섹션에서 연결 해제하시겠습니까?\n(항목 데이터는 항목 탭에 유지됩니다)')) {
                                         deleteField(String(selectedPage.id), String(section.id), String(field.id));
diff --git a/src/components/molecules/IconWithBadge.tsx b/src/components/molecules/IconWithBadge.tsx
new file mode 100644
index 00000000..7893f0cc
--- /dev/null
+++ b/src/components/molecules/IconWithBadge.tsx
@@ -0,0 +1,51 @@
+"use client";
+
+import { LucideIcon } from "lucide-react";
+import { Badge } from "@/components/ui/badge";
+import { cn } from "@/lib/utils";
+
+interface IconWithBadgeProps {
+  icon: LucideIcon;
+  iconColor?: string;
+  iconBgColor?: string;
+  label?: string;
+  badge?: {
+    label: string;
+    variant?: "default" | "secondary" | "destructive" | "outline";
+    className?: string;
+  };
+  size?: "sm" | "md" | "lg";
+}
+
+export const IconWithBadge = ({
+  icon: Icon,
+  iconColor = "text-blue-600",
+  iconBgColor = "bg-blue-100",
+  label,
+  badge,
+  size = "md"
+}: IconWithBadgeProps) => {
+  const sizeClasses = {
+    sm: { container: "w-6 h-6", icon: "w-3 h-3" },
+    md: { container: "w-8 h-8", icon: "w-4 h-4" },
+    lg: { container: "w-10 h-10", icon: "w-5 h-5" }
+  };
+
+  return (
+    <div className="flex items-center gap-2">
+      <div className={cn(
+        "rounded-lg flex items-center justify-center",
+        iconBgColor,
+        sizeClasses[size].container
+      )}>
+        <Icon className={cn(iconColor, sizeClasses[size].icon)} />
+      </div>
+      {label && <span className="font-medium">{label}</span>}
+      {badge && (
+        <Badge variant={badge.variant} className={badge.className}>
+          {badge.label}
+        </Badge>
+      )}
+    </div>
+  );
+};
\ No newline at end of file
diff --git a/src/components/molecules/StandardDialog.tsx b/src/components/molecules/StandardDialog.tsx
new file mode 100644
index 00000000..8e1a8b2a
--- /dev/null
+++ b/src/components/molecules/StandardDialog.tsx
@@ -0,0 +1,219 @@
+"use client";
+
+/**
+ * 표준 다이얼로그 컴포넌트
+ *
+ * 디자인시스템관리 -> 다이얼로그 기준으로 작성된 공통 다이얼로그
+ * - 반응형 지원 (모바일/태블릿/데스크톱)
+ * - 접근성 준수 (DialogTitle 필수)
+ * - 일관된 스타일링
+ * - 상/하/좌/우 모든 마진 적용
+ */
+
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+
+export interface StandardDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  title: string;
+  description?: string;
+  children: React.ReactNode;
+  footer?: React.ReactNode;
+  size?: "sm" | "md" | "lg" | "xl" | "full";
+  showClose?: boolean;
+  className?: string;
+}
+
+const sizeClasses = {
+  sm: "sm:max-w-sm",
+  md: "sm:max-w-md",
+  lg: "sm:max-w-lg",
+  xl: "sm:max-w-xl",
+  full: "sm:max-w-[95vw]",
+};
+
+/**
+ * 표준 다이얼로그
+ *
+ * @example
+ * ```tsx
+ * <StandardDialog
+ *   open={isOpen}
+ *   onOpenChange={setIsOpen}
+ *   title="품목 등록"
+ *   description="새로운 품목을 등록합니다"
+ *   size="lg"
+ * >
+ *   <div>컨텐츠</div>
+ * </StandardDialog>
+ * ```
+ */
+export function StandardDialog({
+  open,
+  onOpenChange,
+  title,
+  description,
+  children,
+  footer,
+  size = "md",
+  showClose = true,
+  className,
+}: StandardDialogProps) {
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className={cn(sizeClasses[size], className)}>
+        <DialogHeader className="px-6 pt-6">
+          <DialogTitle>{title}</DialogTitle>
+          {description && <DialogDescription>{description}</DialogDescription>}
+        </DialogHeader>
+
+        <div className="px-6 pb-6 overflow-y-auto max-h-[60vh]">{children}</div>
+
+        {footer && <DialogFooter>{footer}</DialogFooter>}
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+/**
+ * 확인 다이얼로그
+ */
+export interface ConfirmDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  title: string;
+  description: string;
+  onConfirm: () => void;
+  confirmText?: string;
+  cancelText?: string;
+  confirmVariant?:
+    | "default"
+    | "destructive"
+    | "outline"
+    | "secondary"
+    | "ghost"
+    | "link";
+  loading?: boolean;
+}
+
+export function ConfirmDialog({
+  open,
+  onOpenChange,
+  title,
+  description,
+  onConfirm,
+  confirmText = "확인",
+  cancelText = "취소",
+  confirmVariant = "default",
+  loading = false,
+}: ConfirmDialogProps) {
+  const handleConfirm = () => {
+    onConfirm();
+    onOpenChange(false);
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader className="px-6 pt-6">
+          <DialogTitle>{title}</DialogTitle>
+          <DialogDescription>{description}</DialogDescription>
+        </DialogHeader>
+
+        <div className="px-6 pb-4"></div>
+
+        <DialogFooter>
+          <Button
+            variant="outline"
+            onClick={() => onOpenChange(false)}
+            disabled={loading}
+          >
+            {cancelText}
+          </Button>
+          <Button
+            variant={confirmVariant}
+            onClick={handleConfirm}
+            disabled={loading}
+          >
+            {confirmText}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+/**
+ * 폼 다이얼로그
+ */
+export interface FormDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  title: string;
+  description?: string;
+  children: React.ReactNode;
+  onSave: () => void;
+  onCancel?: () => void;
+  saveText?: string;
+  cancelText?: string;
+  size?: "sm" | "md" | "lg" | "xl" | "full";
+  loading?: boolean;
+  disabled?: boolean;
+}
+
+export function FormDialog({
+  open,
+  onOpenChange,
+  title,
+  description,
+  children,
+  onSave,
+  onCancel,
+  saveText = "저장",
+  cancelText = "취소",
+  size = "md",
+  loading = false,
+  disabled = false,
+}: FormDialogProps) {
+  const handleCancel = () => {
+    if (onCancel) {
+      onCancel();
+    }
+    onOpenChange(false);
+  };
+
+  const handleSave = () => {
+    onSave();
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className={cn(sizeClasses[size])}>
+        <DialogHeader className="px-6 pt-6">
+          <DialogTitle>{title}</DialogTitle>
+          {description && <DialogDescription>{description}</DialogDescription>}
+        </DialogHeader>
+
+        <div className="px-6 pb-4 overflow-y-auto max-h-[60vh]">{children}</div>
+
+        <DialogFooter>
+          <Button variant="outline" onClick={handleCancel} disabled={loading}>
+            {cancelText}
+          </Button>
+          <Button onClick={handleSave} disabled={loading || disabled}>
+            {saveText}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
\ No newline at end of file
diff --git a/src/components/molecules/StatusBadge.tsx b/src/components/molecules/StatusBadge.tsx
new file mode 100644
index 00000000..db2df478
--- /dev/null
+++ b/src/components/molecules/StatusBadge.tsx
@@ -0,0 +1,110 @@
+"use client";
+
+import { Badge } from "@/components/ui/badge";
+import { BadgeSm } from "@/components/atoms/BadgeSm";
+import { LucideIcon } from "lucide-react";
+
+/**
+ * 상태 뱃지 컴포넌트
+ *
+ * 목록 아이템의 상태를 표시하는 공통 뱃지 컴포넌트입니다.
+ * variant와 color를 조합하여 다양한 스타일의 뱃지를 생성할 수 있습니다.
+ *
+ * @example
+ * ```tsx
+ * <StatusBadge variant="success" label="완료" />
+ * <StatusBadge variant="warning" label="진행중" />
+ * <StatusBadge variant="danger" label="취소" />
+ * <StatusBadge variant="info" label="대기" />
+ * <StatusBadge variant="default" label="초안" />
+ * ```
+ */
+
+export type StatusType = "default" | "success" | "warning" | "danger" | "info" | "secondary" | "outline";
+
+export interface StatusBadgeProps {
+  /** 뱃지 텍스트 */
+  label: string;
+
+  /** 뱃지 변형 스타일 */
+  variant?: StatusType;
+
+  /** 커스텀 배경색 (Tailwind 클래스) */
+  bgColor?: string;
+
+  /** 커스텀 텍스트 색상 (Tailwind 클래스) */
+  textColor?: string;
+
+  /** 커스텀 테두리 색상 (Tailwind 클래스) */
+  borderColor?: string;
+
+  /** 아이콘 (선택사항) */
+  icon?: LucideIcon;
+
+  /** 추가 className */
+  className?: string;
+
+  /** 크기 */
+  size?: "sm" | "md" | "lg";
+
+  /** 점 표시 여부 (DataTable에서 사용) */
+  showDot?: boolean;
+}
+
+export function StatusBadge({
+  label,
+  variant = "default",
+  bgColor,
+  textColor,
+  borderColor,
+  icon: Icon,
+  className = "",
+  size = "md",
+  showDot
+}: StatusBadgeProps) {
+  // variant에 따른 기본 스타일
+  const variantStyles: Record<string, string> = {
+    default: "bg-gray-100 text-gray-700 border-gray-300",
+    success: "bg-green-100 text-green-700 border-green-300",
+    warning: "bg-orange-100 text-orange-700 border-orange-300",
+    danger: "bg-red-100 text-red-700 border-red-300",
+    info: "bg-blue-100 text-blue-700 border-blue-300",
+    secondary: "bg-purple-100 text-purple-700 border-purple-300",
+    outline: "bg-white text-gray-700 border-gray-300"
+  };
+
+  // 크기별 스타일
+  const sizeStyles: Record<string, string> = {
+    sm: "text-xs px-2 py-0.5",
+    md: "text-sm px-2.5 py-1",
+    lg: "text-base px-3 py-1.5"
+  };
+
+  // 커스텀 색상이 있으면 사용, 없으면 variant 스타일 사용
+  const colorClasses = bgColor || textColor || borderColor
+    ? `${bgColor || ""} ${textColor || ""} ${borderColor || ""}`
+    : variantStyles[variant];
+
+  // size가 sm이면 BadgeSm 사용
+  if (size === "sm") {
+    return (
+      <BadgeSm
+        variant="default"
+        className={`${colorClasses} font-medium ${className}`}
+      >
+        {Icon && <Icon className="h-3 w-3 mr-1" />}
+        {label}
+      </BadgeSm>
+    );
+  }
+
+  return (
+    <Badge
+      variant="outline"
+      className={`${colorClasses} ${sizeStyles[size]} font-medium ${className}`}
+    >
+      {Icon && <Icon className="h-3 w-3 mr-1" />}
+      {label}
+    </Badge>
+  );
+}
\ No newline at end of file
diff --git a/src/components/molecules/TableActions.tsx b/src/components/molecules/TableActions.tsx
new file mode 100644
index 00000000..2a50d73e
--- /dev/null
+++ b/src/components/molecules/TableActions.tsx
@@ -0,0 +1,89 @@
+"use client";
+
+import { Button } from "@/components/ui/button";
+import { LucideIcon, Eye, Edit, Trash2, Copy, Download, MoreHorizontal } from "lucide-react";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+
+export interface TableAction {
+  type: "view" | "edit" | "delete" | "copy" | "download" | "custom";
+  label?: string;
+  icon?: LucideIcon;
+  onClick: () => void;
+  variant?: "default" | "ghost" | "outline" | "destructive";
+  hidden?: boolean;
+}
+
+interface TableActionsProps {
+  actions: TableAction[];
+  layout?: "buttons" | "dropdown" | "auto";
+}
+
+const defaultIcons: Record<string, LucideIcon> = {
+  view: Eye,
+  edit: Edit,
+  delete: Trash2,
+  copy: Copy,
+  download: Download
+};
+
+export const TableActions = ({ actions, layout = "auto" }: TableActionsProps) => {
+  const visibleActions = actions.filter(a => !a.hidden);
+
+  // 자동 레이아웃: 3개 이하는 버튼, 4개 이상은 드롭다운
+  const useDropdown = layout === "dropdown" || (layout === "auto" && visibleActions.length > 3);
+
+  if (visibleActions.length === 0) return null;
+
+  // 드롭다운 레이아웃
+  if (useDropdown) {
+    return (
+      <DropdownMenu>
+        <DropdownMenuTrigger asChild>
+          <Button variant="ghost" size="sm">
+            <MoreHorizontal className="w-4 h-4" />
+          </Button>
+        </DropdownMenuTrigger>
+        <DropdownMenuContent align="end">
+          {visibleActions.map((action, index) => {
+            const Icon = action.icon || (action.type !== "custom" ? defaultIcons[action.type] : null);
+            return (
+              <DropdownMenuItem
+                key={index}
+                onClick={action.onClick}
+                className={action.variant === "destructive" ? "text-destructive" : ""}
+              >
+                {Icon && <Icon className="w-4 h-4 mr-2" />}
+                {action.label || action.type.charAt(0).toUpperCase() + action.type.slice(1)}
+              </DropdownMenuItem>
+            );
+          })}
+        </DropdownMenuContent>
+      </DropdownMenu>
+    );
+  }
+
+  // 버튼 레이아웃
+  return (
+    <div className="flex gap-1">
+      {visibleActions.map((action, index) => {
+        const Icon = action.icon || (action.type !== "custom" ? defaultIcons[action.type] : null);
+        return (
+          <Button
+            key={index}
+            variant={action.variant || "ghost"}
+            size="sm"
+            onClick={action.onClick}
+            title={action.label || action.type}
+          >
+            {Icon && <Icon className="w-4 h-4" />}
+          </Button>
+        );
+      })}
+    </div>
+  );
+};
\ No newline at end of file
diff --git a/src/components/molecules/index.ts b/src/components/molecules/index.ts
new file mode 100644
index 00000000..cd0d5be5
--- /dev/null
+++ b/src/components/molecules/index.ts
@@ -0,0 +1,10 @@
+export { StatusBadge } from "./StatusBadge";
+export type { StatusBadgeProps, StatusType } from "./StatusBadge";
+
+export { IconWithBadge } from "./IconWithBadge";
+
+export { TableActions } from "./TableActions";
+export type { TableAction } from "./TableActions";
+
+export { StandardDialog, ConfirmDialog, FormDialog } from "./StandardDialog";
+export type { StandardDialogProps, ConfirmDialogProps, FormDialogProps } from "./StandardDialog";
\ No newline at end of file
diff --git a/src/components/organisms/DataTable.tsx b/src/components/organisms/DataTable.tsx
new file mode 100644
index 00000000..b2188563
--- /dev/null
+++ b/src/components/organisms/DataTable.tsx
@@ -0,0 +1,316 @@
+"use client";
+
+import { ReactNode } from "react";
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table";
+import { Card, CardContent } from "@/components/ui/card";
+import { Button } from "@/components/ui/button";
+import { ChevronLeft, ChevronRight, LucideIcon } from "lucide-react";
+import { StatusBadge, StatusType } from "@/components/molecules/StatusBadge";
+import { IconWithBadge } from "@/components/molecules/IconWithBadge";
+import { TableActions, TableAction } from "@/components/molecules/TableActions";
+import { Badge } from "@/components/ui/badge";
+import { cn } from "@/lib/utils";
+
+// 셀 타입 정의
+export type CellType =
+  | "text"           // 일반 텍스트
+  | "number"         // 숫자 (우측 정렬)
+  | "currency"       // 통화 (₩ 표시)
+  | "date"           // 날짜
+  | "datetime"       // 날짜 + 시간
+  | "status"         // 상태 배지
+  | "badge"          // 일반 배지
+  | "icon"           // 아이콘
+  | "iconBadge"      // 아이콘 + 배지
+  | "actions"        // 액션 버튼들
+  | "custom";        // 커스텀 렌더링
+
+export interface Column<T> {
+  key: keyof T | string;
+  label: string;
+  type?: CellType;
+  width?: string;
+  align?: "left" | "center" | "right";
+  sortable?: boolean;
+  className?: string;
+
+  // 타입별 설정
+  statusConfig?: {
+    showDot?: boolean;
+  };
+  badgeConfig?: {
+    variant?: "default" | "secondary" | "destructive" | "outline";
+    className?: string;
+  };
+  iconConfig?: {
+    iconColor?: string;
+    iconBgColor?: string;
+    size?: "sm" | "md" | "lg";
+  };
+  currencyConfig?: {
+    locale?: string;
+    currency?: string;
+  };
+  dateConfig?: {
+    format?: "short" | "long" | "relative";
+  };
+
+  // 커스텀 렌더링
+  render?: (value: any, row: T, index?: number) => ReactNode;
+
+  // 값 변환
+  format?: (value: any) => string | number;
+}
+
+interface DataTableProps<T> {
+  columns: Column<T>[];
+  data: T[];
+  keyField: keyof T;
+  onRowClick?: (row: T) => void;
+  loading?: boolean;
+  emptyMessage?: string;
+  pagination?: {
+    currentPage: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+    showInfo?: boolean;
+  };
+  striped?: boolean;
+  hoverable?: boolean;
+  compact?: boolean;
+}
+
+// 셀 렌더러
+function renderCell<T>(column: Column<T>, value: any, row: T, index?: number): ReactNode {
+  // 값 포맷팅 또는 render 호출
+  let formattedValue: any;
+
+  if (column.render) {
+    formattedValue = column.render(value, row, index);
+  } else if (column.format) {
+    formattedValue = column.format(value);
+  } else {
+    formattedValue = value;
+  }
+
+  // 타입별 렌더링
+  switch (column.type) {
+    case "number":
+      return <span className="font-mono">{formattedValue?.toLocaleString()}</span>;
+
+    case "currency":
+      const locale = column.currencyConfig?.locale || "ko-KR";
+      const currency = column.currencyConfig?.currency || "KRW";
+      const currencyValue = typeof formattedValue === "number"
+        ? formattedValue.toLocaleString(locale, { style: "currency", currency })
+        : formattedValue;
+      return <span className="font-mono">{currencyValue}</span>;
+
+    case "date":
+      if (!formattedValue) return "-";
+      const dateValue = new Date(formattedValue);
+      return <span className="text-sm">{dateValue.toLocaleDateString("ko-KR")}</span>;
+
+    case "datetime":
+      if (!formattedValue) return "-";
+      const datetimeValue = new Date(formattedValue);
+      return (
+        <span className="text-sm">
+          {datetimeValue.toLocaleDateString("ko-KR")} {datetimeValue.toLocaleTimeString("ko-KR", { hour: "2-digit", minute: "2-digit" })}
+        </span>
+      );
+
+    case "status":
+      return (
+        <StatusBadge
+          label={formattedValue as string}
+          variant={formattedValue as StatusType}
+          showDot={column.statusConfig?.showDot}
+        />
+      );
+
+    case "badge":
+      return (
+        <Badge
+          variant={column.badgeConfig?.variant}
+          className={column.badgeConfig?.className}
+        >
+          {formattedValue}
+        </Badge>
+      );
+
+    case "icon":
+      const IconComponent = formattedValue as LucideIcon;
+      return IconComponent ? (
+        <IconWithBadge
+          icon={IconComponent}
+          iconColor={column.iconConfig?.iconColor}
+          iconBgColor={column.iconConfig?.iconBgColor}
+          size={column.iconConfig?.size}
+        />
+      ) : null;
+
+    case "iconBadge":
+      // value should be { icon, label, badge }
+      if (typeof formattedValue === "object" && formattedValue.icon) {
+        return (
+          <IconWithBadge
+            icon={formattedValue.icon}
+            label={formattedValue.label}
+            badge={formattedValue.badge}
+            iconColor={column.iconConfig?.iconColor}
+            iconBgColor={column.iconConfig?.iconBgColor}
+            size={column.iconConfig?.size}
+          />
+        );
+      }
+      return formattedValue;
+
+    case "actions":
+      // render 함수가 TableAction[] 배열을 반환해야 함
+      const actions = Array.isArray(formattedValue) ? formattedValue : [];
+      return actions.length > 0 ? <TableActions actions={actions} /> : null;
+
+    case "custom":
+      // 커스텀 타입은 이미 render 함수에서 처리됨
+      return formattedValue;
+
+    case "text":
+    default:
+      return formattedValue ?? "-";
+  }
+}
+
+// 정렬 함수
+function getAlignClass(column: Column<any>): string {
+  if (column.align) {
+    return column.align === "center" ? "text-center" : column.align === "right" ? "text-right" : "text-left";
+  }
+
+  // 타입별 기본 정렬
+  switch (column.type) {
+    case "number":
+    case "currency":
+    case "actions":
+      return "text-right";
+    case "status":
+    case "badge":
+    case "icon":
+    case "iconBadge":
+      return "text-center";
+    default:
+      return "text-left";
+  }
+}
+
+export function DataTable<T>({
+  columns,
+  data,
+  keyField,
+  onRowClick,
+  loading,
+  emptyMessage = "데이터가 없습니다.",
+  pagination,
+  striped = false,
+  hoverable = true,
+  compact = false
+}: DataTableProps<T>) {
+  return (
+    <Card className="hidden md:block">
+      <CardContent className="p-0">
+        <div className="overflow-x-auto">
+          <Table>
+            <TableHeader>
+              <TableRow>
+                {columns.map((column) => (
+                  <TableHead
+                    key={String(column.key)}
+                    className={cn(
+                      getAlignClass(column),
+                      column.className,
+                      column.width && `w-[${column.width}]`
+                    )}
+                  >
+                    {column.label}
+                  </TableHead>
+                ))}
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {loading ? (
+                <TableRow>
+                  <TableCell colSpan={columns.length} className="text-center py-8 text-muted-foreground">
+                    로딩 중...
+                  </TableCell>
+                </TableRow>
+              ) : data.length === 0 ? (
+                <TableRow>
+                  <TableCell colSpan={columns.length} className="text-center py-8 text-muted-foreground">
+                    {emptyMessage}
+                  </TableCell>
+                </TableRow>
+              ) : (
+                data.map((row, rowIndex) => (
+                  <TableRow
+                    key={row[keyField] ? String(row[keyField]) : `row-${rowIndex}`}
+                    onClick={() => onRowClick?.(row)}
+                    className={cn(
+                      onRowClick && "cursor-pointer",
+                      hoverable && "hover:bg-muted/50",
+                      striped && rowIndex % 2 === 1 && "bg-muted/20",
+                      compact && "h-10"
+                    )}
+                  >
+                    {columns.map((column) => {
+                      const value = column.key in row ? row[column.key as keyof T] : null;
+                      return (
+                        <TableCell
+                          key={String(column.key)}
+                          className={cn(
+                            getAlignClass(column),
+                            column.className,
+                            compact && "py-2"
+                          )}
+                        >
+                          {renderCell(column, value, row, rowIndex)}
+                        </TableCell>
+                      );
+                    })}
+                  </TableRow>
+                ))
+              )}
+            </TableBody>
+          </Table>
+        </div>
+
+        {pagination && pagination.totalPages > 1 && (
+          <div className="flex items-center justify-between p-4 border-t">
+            {pagination.showInfo !== false && (
+              <p className="text-sm text-muted-foreground">
+                페이지 {pagination.currentPage} / {pagination.totalPages}
+              </p>
+            )}
+            <div className="flex gap-2 ml-auto">
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => pagination.onPageChange(pagination.currentPage - 1)}
+                disabled={pagination.currentPage === 1}
+              >
+                <ChevronLeft className="w-4 h-4" />
+              </Button>
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => pagination.onPageChange(pagination.currentPage + 1)}
+                disabled={pagination.currentPage === pagination.totalPages}
+              >
+                <ChevronRight className="w-4 h-4" />
+              </Button>
+            </div>
+          </div>
+        )}
+      </CardContent>
+    </Card>
+  );
+}
\ No newline at end of file
diff --git a/src/components/organisms/EmptyState.tsx b/src/components/organisms/EmptyState.tsx
new file mode 100644
index 00000000..00cc0004
--- /dev/null
+++ b/src/components/organisms/EmptyState.tsx
@@ -0,0 +1,37 @@
+"use client";
+
+import { LucideIcon } from "lucide-react";
+import { Button } from "@/components/ui/button";
+
+interface EmptyStateProps {
+  icon?: LucideIcon;
+  title: string;
+  description?: string;
+  action?: {
+    label: string;
+    onClick: () => void;
+  };
+}
+
+export function EmptyState({ icon: Icon, title, description, action }: EmptyStateProps) {
+  return (
+    <div className="flex flex-col items-center justify-center py-12 text-center">
+      {Icon && (
+        <div className="mb-4 p-4 bg-muted rounded-full">
+          <Icon className="w-8 h-8 text-muted-foreground" />
+        </div>
+      )}
+      <h3 className="text-lg font-semibold mb-2">{title}</h3>
+      {description && (
+        <p className="text-sm text-muted-foreground mb-6 max-w-md">
+          {description}
+        </p>
+      )}
+      {action && (
+        <Button onClick={action.onClick}>
+          {action.label}
+        </Button>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/organisms/ListMobileCard.tsx b/src/components/organisms/ListMobileCard.tsx
new file mode 100644
index 00000000..3f1e0849
--- /dev/null
+++ b/src/components/organisms/ListMobileCard.tsx
@@ -0,0 +1,170 @@
+"use client";
+
+import { ReactNode } from "react";
+import { Checkbox } from "@/components/ui/checkbox";
+import { Separator } from "@/components/ui/separator";
+
+/**
+ * 목록 모바일 카드 컴포넌트
+ *
+ * 모바일 환경에서 사용하는 공통 목록 카드 컴포넌트입니다.
+ * 체크박스, 헤더, 뱃지, 정보 그리드, 액션 버튼을 포함합니다.
+ *
+ * @example
+ * ```tsx
+ * <ListMobileCard
+ *   id="item-1"
+ *   isSelected={false}
+ *   onToggleSelection={() => handleToggle("item-1")}
+ *   onCardClick={() => handleView("item-1")}
+ *   headerBadges={[
+ *     <Badge key="num">#{1}</Badge>,
+ *     <Badge key="code">Q2024-001</Badge>
+ *   ]}
+ *   title="ABC건설"
+ *   statusBadge={<StatusBadge variant="success" label="완료" />}
+ *   infoGrid={
+ *     <div className="grid grid-cols-2 gap-x-4 gap-y-3">
+ *       <InfoField label="현장명" value="강남 현장" />
+ *       <InfoField label="담당자" value="김철수" />
+ *     </div>
+ *   }
+ *   actions={isSelected && <ActionButtonGroup actions={actions} isMobile />}
+ * />
+ * ```
+ */
+
+export interface ListMobileCardProps {
+  /** 아이템 고유 ID */
+  id: string;
+
+  /** 선택 상태 */
+  isSelected: boolean;
+
+  /** 체크박스 토글 핸들러 */
+  onToggleSelection: () => void;
+
+  /** 카드 클릭 핸들러 */
+  onCardClick?: () => void;
+
+  /** 헤더 영역 뱃지들 (번호, 코드 등) */
+  headerBadges?: ReactNode;
+
+  /** 카드 제목 (주요 정보) */
+  title: string;
+
+  /** 상태 뱃지 (우측 상단) */
+  statusBadge?: ReactNode;
+
+  /** 정보 그리드 영역 */
+  infoGrid: ReactNode;
+
+  /** 액션 버튼 영역 */
+  actions?: ReactNode;
+
+  /** 추가 className */
+  className?: string;
+
+  /** 카드 상단 추가 콘텐츠 */
+  topContent?: ReactNode;
+
+  /** 카드 하단 추가 콘텐츠 */
+  bottomContent?: ReactNode;
+}
+
+/**
+ * 정보 필드 컴포넌트
+ *
+ * 카드 내부의 레이블-값 쌍을 표시합니다.
+ */
+export interface InfoFieldProps {
+  label: string;
+  value: string | number | ReactNode;
+  valueClassName?: string;
+}
+
+export function InfoField({ label, value, valueClassName = "" }: InfoFieldProps) {
+  return (
+    <div className="space-y-0.5">
+      <p className="text-xs text-muted-foreground">{label}</p>
+      <div className={`text-sm font-medium ${valueClassName}`}>{value}</div>
+    </div>
+  );
+}
+
+export function ListMobileCard({
+  id,
+  isSelected,
+  onToggleSelection,
+  onCardClick,
+  headerBadges,
+  title,
+  statusBadge,
+  infoGrid,
+  actions,
+  className = "",
+  topContent,
+  bottomContent
+}: ListMobileCardProps) {
+  return (
+    <div
+      className={`border rounded-lg p-5 space-y-4 bg-white dark:bg-card transition-all cursor-pointer ${
+        isSelected
+          ? 'border-blue-500 bg-blue-50/50'
+          : 'border-gray-200 hover:border-primary/50'
+      } ${className}`}
+      onClick={onCardClick}
+    >
+      {/* 상단 추가 콘텐츠 */}
+      {topContent}
+
+      {/* 헤더: 체크박스 + 뱃지 + 제목 / 우측에 상태 뱃지 */}
+      <div className="flex items-start justify-between gap-4">
+        <div className="flex items-start gap-3 flex-1 min-w-0">
+          <Checkbox
+            checked={isSelected}
+            onCheckedChange={onToggleSelection}
+            onClick={(e) => e.stopPropagation()}
+            className="mt-0.5 h-5 w-5"
+          />
+          <div className="flex-1 min-w-0">
+            {/* 헤더 뱃지들 (번호, 코드 등) */}
+            {headerBadges && (
+              <div className="flex items-center gap-2 flex-wrap mb-2">
+                {headerBadges}
+              </div>
+            )}
+            {/* 제목 */}
+            <h3 className="font-semibold text-gray-900 font-bold whitespace-nowrap">
+              {title}
+            </h3>
+          </div>
+        </div>
+
+        {/* 우측 상단: 상태 뱃지 */}
+        {statusBadge && (
+          <div className="shrink-0">
+            {statusBadge}
+          </div>
+        )}
+      </div>
+
+      {/* 구분선 */}
+      <Separator className="bg-gray-100" />
+
+      {/* 정보 그리드 */}
+      {infoGrid}
+
+      {/* 액션 버튼 - 선택된 경우만 표시 */}
+      {actions && (
+        <>
+          <Separator className="bg-gray-100" />
+          {actions}
+        </>
+      )}
+
+      {/* 하단 추가 콘텐츠 */}
+      {bottomContent}
+    </div>
+  );
+}
diff --git a/src/components/organisms/MobileCard.tsx b/src/components/organisms/MobileCard.tsx
new file mode 100644
index 00000000..dc29233e
--- /dev/null
+++ b/src/components/organisms/MobileCard.tsx
@@ -0,0 +1,106 @@
+"use client";
+
+import { Card, CardContent } from "@/components/ui/card";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { ReactNode, ComponentType } from "react";
+import { LucideIcon } from "lucide-react";
+
+interface MobileCardProps {
+  title: string;
+  subtitle?: string;
+  icon?: ReactNode;
+  badge?: {
+    label: string;
+    variant?: "default" | "secondary" | "destructive" | "outline";
+  };
+  fields: Array<{
+    label: string;
+    value: string;
+    badge?: boolean;
+    badgeVariant?: string;
+  }>;
+  actions?: Array<{
+    label: string;
+    onClick: () => void;
+    icon?: LucideIcon | ComponentType<any>;
+    variant?: "default" | "outline" | "destructive";
+  }>;
+  onCardClick?: () => void;
+}
+
+export function MobileCard({
+  title,
+  subtitle,
+  icon,
+  badge,
+  fields,
+  actions,
+  onCardClick
+}: MobileCardProps) {
+  return (
+    <Card className={onCardClick ? "cursor-pointer hover:shadow-md transition-shadow" : ""}>
+      <CardContent className="p-4 cursor-pointer active:bg-muted/50 transition-colors" onClick={onCardClick}>
+        <div className="space-y-3">
+          {/* Header */}
+          <div className="flex items-start justify-between">
+            <div className="flex items-start gap-2 flex-1">
+              {icon && <div className="mt-1">{icon}</div>}
+              <div className="flex-1 min-w-0">
+                <h4 className="font-semibold truncate">{title}</h4>
+                {subtitle && (
+                  <p className="text-sm text-muted-foreground truncate">
+                    {subtitle}
+                  </p>
+                )}
+              </div>
+            </div>
+            {badge && (
+              <Badge variant={badge.variant || "default"} className="ml-2">
+                {badge.label}
+              </Badge>
+            )}
+          </div>
+
+          {/* Fields */}
+          <div className="space-y-2">
+            {fields.map((field, index) => (
+              <div key={`${field.label}-${index}`} className="flex justify-between items-center text-sm">
+                <span className="text-muted-foreground">{field.label}</span>
+                {field.badge ? (
+                  <Badge variant="outline">{field.value}</Badge>
+                ) : (
+                  <span className="font-medium">{field.value}</span>
+                )}
+              </div>
+            ))}
+          </div>
+
+          {/* Actions */}
+          {actions && actions.length > 0 && (
+            <div className="flex flex-wrap gap-2 pt-2 border-t">
+              {actions.map((action, index) => {
+                const Icon = action.icon;
+                return (
+                  <Button
+                    key={`${action.label}-${index}`}
+                    variant={action.variant || "outline"}
+                    size="sm"
+                    onClick={(e) => {
+                      e.stopPropagation();
+                      action.onClick();
+                    }}
+                    className="flex-1 min-w-[calc(50%-0.25rem)]"
+                  >
+                    {Icon && <Icon className="w-4 h-4 mr-1" />}
+                    {action.label}
+                  </Button>
+                );
+              })}
+            </div>
+          )}
+        </div>
+      </CardContent>
+    </Card>
+  );
+}
\ No newline at end of file
diff --git a/src/components/organisms/ScreenVersionHistory.tsx b/src/components/organisms/ScreenVersionHistory.tsx
new file mode 100644
index 00000000..d05b4602
--- /dev/null
+++ b/src/components/organisms/ScreenVersionHistory.tsx
@@ -0,0 +1,74 @@
+"use client";
+
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Badge } from "@/components/ui/badge";
+import { History } from "lucide-react";
+
+interface VersionHistoryItem {
+  id: string;
+  version: number;
+  changeDescription: string;
+  changedBy: string;
+  changedAt: string;
+}
+
+interface ScreenVersionHistoryProps {
+  versionHistory: VersionHistoryItem[];
+  title?: string;
+  colorScheme?: {
+    border: string;
+    background: string;
+    text: string;
+  };
+  maxVisible?: number;
+}
+
+export function ScreenVersionHistory({
+  versionHistory,
+  title = "수정 이력",
+  colorScheme = {
+    border: "border-purple-200 dark:border-purple-800",
+    background: "bg-purple-50 dark:bg-purple-950/30",
+    text: "text-purple-700 dark:text-purple-300"
+  },
+  maxVisible = 3
+}: ScreenVersionHistoryProps) {
+  if (versionHistory.length === 0) {
+    return null;
+  }
+
+  return (
+    <Card className={`${colorScheme.border} ${colorScheme.background}`}>
+      <CardHeader>
+        <CardTitle className={`flex items-center gap-2 ${colorScheme.text}`}>
+          <History className="h-5 w-5" />
+          {title}
+        </CardTitle>
+      </CardHeader>
+      <CardContent className="space-y-4">
+        <div className="bg-background border rounded-lg p-4">
+          <div className="text-sm space-y-2">
+            <div className="flex items-center justify-between mb-2">
+              <span className={`font-semibold ${colorScheme.text}`}>최근 수정 이력</span>
+              <Badge variant="secondary">총 {versionHistory.length}건</Badge>
+            </div>
+            <div className="max-h-32 overflow-y-auto space-y-2">
+              {versionHistory.slice().reverse().slice(0, maxVisible).map((history) => (
+                <div key={history.id} className="flex items-center gap-2 text-xs">
+                  <Badge variant="outline">v{history.version}</Badge>
+                  <span className="text-muted-foreground">•</span>
+                  <span>{history.changeDescription}</span>
+                  <span className="text-muted-foreground">•</span>
+                  <span className="text-muted-foreground">{history.changedBy}</span>
+                  <span className="text-muted-foreground ml-auto">
+                    {new Date(history.changedAt).toLocaleDateString('ko-KR')}
+                  </span>
+                </div>
+              ))}
+            </div>
+          </div>
+        </div>
+      </CardContent>
+    </Card>
+  );
+}
diff --git a/src/components/organisms/SearchFilter.tsx b/src/components/organisms/SearchFilter.tsx
new file mode 100644
index 00000000..bc95ec1f
--- /dev/null
+++ b/src/components/organisms/SearchFilter.tsx
@@ -0,0 +1,58 @@
+"use client";
+
+import { Input } from "@/components/ui/input";
+import { Search } from "lucide-react";
+import { ReactNode, useState, useEffect } from "react";
+
+interface SearchFilterProps {
+  searchValue: string;
+  onSearchChange: (value: string) => void;
+  searchPlaceholder?: string;
+  filterButton?: boolean;
+  onFilterClick?: () => void;
+  extraActions?: ReactNode;
+}
+
+export function SearchFilter({
+  searchValue,
+  onSearchChange,
+  searchPlaceholder = "검색",
+  filterButton = true,
+  onFilterClick,
+  extraActions
+}: SearchFilterProps) {
+  const [isMobile, setIsMobile] = useState(false);
+
+  useEffect(() => {
+    const checkMobile = () => {
+      // Next.js SSR 호환성: typeof window 체크
+      if (typeof window !== "undefined") {
+        setIsMobile(window.innerWidth < 640); // sm breakpoint
+      }
+    };
+
+    checkMobile();
+    window.addEventListener('resize', checkMobile);
+
+    return () => window.removeEventListener('resize', checkMobile);
+  }, []);
+
+  return (
+    <div className="flex flex-col sm:flex-row gap-3 sm:items-center">
+      <div className="relative flex-1">
+        <Search className="absolute left-3 top-1/2 transform -translate-y-1/2 text-muted-foreground w-4 h-4" />
+        <Input
+          placeholder={isMobile ? "내용을 검색해주세요." : searchPlaceholder}
+          value={searchValue}
+          onChange={(e) => onSearchChange(e.target.value)}
+          className="pl-10 text-[14px]"
+        />
+      </div>
+      {extraActions && (
+        <div className="flex gap-2 sm:ml-auto">
+          {extraActions}
+        </div>
+      )}
+    </div>
+  );
+}
\ No newline at end of file
diff --git a/src/components/organisms/StatCards.tsx b/src/components/organisms/StatCards.tsx
new file mode 100644
index 00000000..3c6ab415
--- /dev/null
+++ b/src/components/organisms/StatCards.tsx
@@ -0,0 +1,55 @@
+"use client";
+
+import { Card, CardContent } from "@/components/ui/card";
+import { LucideIcon } from "lucide-react";
+
+interface StatCardData {
+  label: string;
+  value: string | number;
+  icon?: LucideIcon;
+  iconColor?: string;
+  trend?: {
+    value: string;
+    isPositive: boolean;
+  };
+}
+
+interface StatCardsProps {
+  stats: StatCardData[];
+}
+
+export function StatCards({ stats }: StatCardsProps) {
+  return (
+    <div className="grid grid-cols-2 lg:grid-cols-4 gap-3 md:gap-4">
+      {stats.map((stat, index) => {
+        const Icon = stat.icon;
+        return (
+          <Card key={index}>
+            <CardContent className="p-3 md:p-4 lg:p-6">
+              <div className="flex items-center justify-between">
+                <div className="flex-1">
+                  <p className="sm:text-xs md:text-sm text-muted-foreground mb-1 md:mb-2 uppercase tracking-wide text-[12px]">
+                    {stat.label}
+                  </p>
+                  <p className="font-bold text-[24px]">
+                    {stat.value}
+                  </p>
+                  {stat.trend && (
+                    <p className={`text-[10px] sm:text-xs md:text-sm mt-1 md:mt-2 font-medium ${stat.trend.isPositive ? 'text-green-600' : 'text-red-600'}`}>
+                      {stat.trend.value}
+                    </p>
+                  )}
+                </div>
+                {Icon && (
+                  <Icon
+                    className={`w-8 h-8 sm:w-9 sm:h-9 md:w-10 md:h-10 lg:w-12 lg:h-12 opacity-15 ${stat.iconColor || 'text-blue-600'}`}
+                  />
+                )}
+              </div>
+            </CardContent>
+          </Card>
+        );
+      })}
+    </div>
+  );
+}
\ No newline at end of file
diff --git a/src/components/organisms/index.ts b/src/components/organisms/index.ts
new file mode 100644
index 00000000..e36b6bf0
--- /dev/null
+++ b/src/components/organisms/index.ts
@@ -0,0 +1,11 @@
+export { PageHeader } from "./PageHeader";
+export { PageLayout } from "./PageLayout";
+export { StatCards } from "./StatCards";
+export { SearchFilter } from "./SearchFilter";
+export { DataTable } from "./DataTable";
+export type { Column, CellType } from "./DataTable";
+export { MobileCard } from "./MobileCard";
+export { ListMobileCard, InfoField } from "./ListMobileCard";
+export type { ListMobileCardProps, InfoFieldProps } from "./ListMobileCard";
+export { EmptyState } from "./EmptyState";
+export { ScreenVersionHistory } from "./ScreenVersionHistory";
diff --git a/src/components/templates/IntegratedListTemplateV2.tsx b/src/components/templates/IntegratedListTemplateV2.tsx
new file mode 100644
index 00000000..657a5b00
--- /dev/null
+++ b/src/components/templates/IntegratedListTemplateV2.tsx
@@ -0,0 +1,452 @@
+"use client";
+
+import { ReactNode, Fragment, useState, RefObject } from "react";
+import { LucideIcon, Trash2 } from "lucide-react";
+import { Card, CardContent } from "@/components/ui/card";
+import { Tabs, TabsContent } from "@/components/ui/tabs";
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table";
+import { Checkbox } from "@/components/ui/checkbox";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { PageLayout } from "@/components/organisms/PageLayout";
+import { PageHeader } from "@/components/organisms/PageHeader";
+import { StatCards } from "@/components/organisms/StatCards";
+import { SearchFilter } from "@/components/organisms/SearchFilter";
+import { ScreenVersionHistory } from "@/components/organisms/ScreenVersionHistory";
+import { TabChip } from "@/components/atoms/TabChip";
+
+/**
+ * 기본 통합 목록_버젼2
+ *
+ * 품목관리 스타일의 완전한 목록 템플릿
+ * - PageHeader, StatCards, SearchFilter, ScreenVersionHistory
+ * - 탭 기반 필터 (데스크톱: TabsList, 모바일: 커스텀 버튼)
+ * - 체크박스 포함 DataTable (Desktop)
+ * - 체크박스 포함 모바일 카드 (Mobile)
+ * - 페이지네이션
+ */
+
+export interface TabOption {
+  value: string;
+  label: string;
+  count: number;
+  color?: string; // 모바일 탭 색상
+}
+
+export interface TableColumn {
+  key: string;
+  label: string;
+  className?: string;
+  hideOnMobile?: boolean;
+  hideOnTablet?: boolean;
+}
+
+export interface PaginationConfig {
+  currentPage: number;
+  totalPages: number;
+  totalItems: number;
+  itemsPerPage: number;
+  onPageChange: (page: number) => void;
+}
+
+export interface StatCard {
+  label: string;
+  value: number;
+  icon: LucideIcon;
+  iconColor: string;
+}
+
+export interface VersionHistoryItem {
+  version: string;
+  description: string;
+  modifiedBy: string;
+  modifiedAt: string;
+}
+
+export interface DevMetadata {
+  componentName: string;
+  pagePath: string;
+  description: string;
+  apis?: any[];
+  dataStructures?: any[];
+  dbSchema?: any[];
+  businessLogic?: any[];
+}
+
+export interface IntegratedListTemplateV2Props<T = any> {
+  // 페이지 헤더
+  title: string;
+  description?: string;
+  icon?: LucideIcon;
+  headerActions?: ReactNode;
+
+  // 통계 카드
+  stats?: StatCard[];
+
+  // 버전 이력
+  versionHistory?: VersionHistoryItem[];
+  versionHistoryTitle?: string;
+
+  // 검색 및 필터
+  searchValue: string;
+  onSearchChange: (value: string) => void;
+  searchPlaceholder?: string;
+  extraFilters?: ReactNode; // Select, DatePicker 등 추가 필터
+
+  // 탭 (품목 유형, 상태 등)
+  tabs: TabOption[];
+  activeTab: string;
+  onTabChange: (value: string) => void;
+
+  // 테이블 컬럼
+  tableColumns: TableColumn[];
+  tableTitle?: string; // "전체 목록 (100개)" 같은 타이틀
+
+  // 데이터
+  data: T[]; // 데스크톱용 페이지네이션된 데이터
+  totalCount?: number; // 전체 데이터 개수 (역순 번호 계산용)
+  allData?: T[]; // 모바일 인피니티 스크롤용 전체 필터된 데이터
+  mobileDisplayCount?: number; // 모바일에서 표시할 개수
+  onLoadMore?: () => void; // 더 불러오기 콜백
+  infinityScrollSentinelRef?: RefObject<HTMLDivElement>; // 인피니티 스크롤용 sentinel ref
+
+  // 체크박스 선택
+  selectedItems: Set<string>;
+  onToggleSelection: (id: string) => void;
+  onToggleSelectAll: () => void;
+  getItemId: (item: T) => string; // 아이템에서 ID 추출
+  onBulkDelete?: () => void; // 일괄 삭제 핸들러
+
+  // 렌더링 함수
+  renderTableRow: (item: T, index: number, globalIndex: number) => ReactNode;
+  renderMobileCard: (item: T, index: number, globalIndex: number, isSelected: boolean, onToggle: () => void) => ReactNode;
+
+  // 페이지네이션
+  pagination: PaginationConfig;
+
+  // 개발자 메타데이터
+  devMetadata?: DevMetadata;
+}
+
+export function IntegratedListTemplateV2<T = any>({
+  title,
+  description,
+  icon,
+  headerActions,
+  stats,
+  versionHistory,
+  versionHistoryTitle = "수정 이력",
+  searchValue,
+  onSearchChange,
+  searchPlaceholder = "검색...",
+  extraFilters,
+  tabs,
+  activeTab,
+  onTabChange,
+  tableColumns,
+  tableTitle,
+  data,
+  totalCount,
+  allData,
+  mobileDisplayCount,
+  onLoadMore,
+  infinityScrollSentinelRef,
+  selectedItems,
+  onToggleSelection,
+  onToggleSelectAll,
+  getItemId,
+  onBulkDelete,
+  renderTableRow,
+  renderMobileCard,
+  pagination,
+  devMetadata,
+}: IntegratedListTemplateV2Props<T>) {
+
+  const [showDeleteDialog, setShowDeleteDialog] = useState(false);
+
+  const startIndex = (pagination.currentPage - 1) * pagination.itemsPerPage;
+  const allSelected = selectedItems.size === data.length && data.length > 0;
+
+  // 일괄삭제 확인 핸들러
+  const handleBulkDeleteClick = () => {
+    setShowDeleteDialog(true);
+  };
+
+  // 일괄삭제 실행
+  const handleConfirmDelete = () => {
+    if (onBulkDelete) {
+      onBulkDelete();
+    }
+    setShowDeleteDialog(false);
+  };
+
+  return (
+    <PageLayout devMetadata={devMetadata}>
+      {/* 페이지 헤더 */}
+      <PageHeader
+        title={title}
+        description={description}
+        icon={icon}
+        actions={headerActions}
+      />
+
+      {/* 통계 카드 - 태블릿/데스크톱 */}
+      {stats && stats.length > 0 && (
+        <div className="hidden md:block">
+          <StatCards stats={stats} />
+        </div>
+      )}
+
+      {/* 버전 이력 */}
+      {versionHistory && versionHistory.length > 0 && (
+        <ScreenVersionHistory
+          versionHistory={versionHistory as any}
+          title={versionHistoryTitle}
+        />
+      )}
+
+      {/* 검색 및 필터 */}
+      <Card>
+        <CardContent className="p-6">
+          <SearchFilter
+            searchValue={searchValue}
+            onSearchChange={onSearchChange}
+            searchPlaceholder={searchPlaceholder}
+            filterButton={false}
+            extraActions={extraFilters}
+          />
+        </CardContent>
+      </Card>
+
+
+      {/* 목록 카드 */}
+      <Card>
+        <CardContent className="pt-6">
+          <Tabs value={activeTab} onValueChange={onTabChange} className="w-full">
+            {/* 데스크톱 (1280px+) - TabChip 탭 */}
+            <div className="hidden xl:block mb-4">
+              <div className="flex flex-wrap gap-2 justify-between items-center">
+                <div className="flex flex-wrap gap-2">
+                  {tabs.map((tab) => (
+                    <TabChip
+                      key={tab.value}
+                      label={tab.label}
+                      count={tab.count}
+                      active={activeTab === tab.value}
+                      onClick={() => onTabChange(tab.value)}
+                      color={tab.color as any}
+                    />
+                  ))}
+                </div>
+                {selectedItems.size >= 2 && onBulkDelete && (
+                  <Button
+                    variant="destructive"
+                    size="sm"
+                    onClick={handleBulkDeleteClick}
+                    className="flex items-center gap-2"
+                  >
+                    <Trash2 className="h-4 w-4" />
+                    선택 삭제 ({selectedItems.size})
+                  </Button>
+                )}
+              </div>
+            </div>
+
+            {/* 탭 컨텐츠 */}
+            {tabs.map((tab) => (
+              <TabsContent key={tab.value} value={tab.value} className="mt-0">
+                {/* 모바일/태블릿/소형 노트북 (~1279px) - 선택 삭제 버튼 */}
+                {selectedItems.size >= 2 && onBulkDelete && (
+                  <div className="xl:hidden fixed bottom-0 left-0 right-0 p-4 bg-white border-t shadow-lg z-50">
+                    <Button
+                      variant="destructive"
+                      size="lg"
+                      onClick={handleBulkDeleteClick}
+                      className="w-full flex items-center justify-center gap-2"
+                    >
+                      <Trash2 className="h-4 w-4" />
+                      선택 삭제 ({selectedItems.size})
+                    </Button>
+                  </div>
+                )}
+
+                {/* 모바일/태블릿/소형 노트북 (~1279px) 카드 뷰 */}
+                <div className="xl:hidden space-y-4 md:space-y-0 md:grid md:grid-cols-2 md:gap-4 lg:grid-cols-3">
+                  {(allData && allData.length > 0 ? allData : data).length === 0 ? (
+                    <div className="text-center py-6 text-muted-foreground border rounded-lg text-[14px]">
+                      검색 결과가 없습니다.
+                    </div>
+                  ) : (
+                    (allData || data).map((item, index) => {
+                      const itemId = getItemId(item);
+                      const isSelected = selectedItems.has(itemId);
+                      // 역순 번호 계산: totalCount가 있으면 역순, 없으면 순차
+                      const globalIndex = totalCount
+                        ? totalCount - index
+                        : index + 1;
+
+                      return (
+                        <div key={itemId}>
+                          {renderMobileCard(
+                            item,
+                            index,
+                            globalIndex,
+                            isSelected,
+                            () => onToggleSelection(itemId)
+                          )}
+                        </div>
+                      );
+                    })
+                  )}
+                  {/* 인피니티 스크롤 Sentinel */}
+                  {infinityScrollSentinelRef && (
+                    <div
+                      ref={infinityScrollSentinelRef}
+                      className="h-10 w-full col-span-full"
+                      aria-hidden="true"
+                    />
+                  )}
+                </div>
+
+                {/* 데스크톱 (1280px+) 테이블 뷰 */}
+                <div className="hidden xl:block rounded-md border overflow-x-auto [&::-webkit-scrollbar]:h-3 [&::-webkit-scrollbar-track]:bg-gray-100 [&::-webkit-scrollbar-thumb]:bg-gray-300 [&::-webkit-scrollbar-thumb]:rounded-full [&::-webkit-scrollbar-thumb]:hover:bg-gray-400" style={{ scrollbarWidth: 'thin', scrollbarColor: '#d1d5db #f3f4f6' }}>
+                  <Table>
+                    <TableHeader>
+                      <TableRow>
+                        <TableHead className="w-[50px] min-w-[50px] max-w-[50px] text-center">
+                          <Checkbox
+                            checked={allSelected}
+                            onCheckedChange={onToggleSelectAll}
+                          />
+                        </TableHead>
+                        {tableColumns.map((column) => {
+                          // "actions" 컬럼은 항상 렌더링하되, 선택된 항목이 없을 때는 빈 헤더로 표시
+                          return (
+                            <TableHead
+                              key={column.key}
+                              className={column.className}
+                            >
+                              {column.key === "actions" && selectedItems.size === 0 ? "" : column.label}
+                            </TableHead>
+                          );
+                        })}
+                      </TableRow>
+                    </TableHeader>
+                    <TableBody className="[&_tr]:h-14 [&_tr]:min-h-[56px] [&_tr]:max-h-[56px]">
+                      {data.length === 0 ? (
+                        <TableRow>
+                          <TableCell
+                            colSpan={tableColumns.length + 1}
+                            className="h-24 text-center"
+                          >
+                            검색 결과가 없습니다.
+                          </TableCell>
+                        </TableRow>
+                      ) : (
+                        data.map((item, index) => {
+                          const itemId = getItemId(item);
+                          // 역순 번호 계산: totalCount가 있으면 역순, 없으면 순차
+                          const globalIndex = totalCount
+                            ? totalCount - (startIndex + index)
+                            : startIndex + index;
+                          return (
+                            <Fragment key={itemId}>
+                              {renderTableRow(item, index, globalIndex)}
+                            </Fragment>
+                          );
+                        })
+                      )}
+                    </TableBody>
+                  </Table>
+                </div>
+              </TabsContent>
+            ))}
+          </Tabs>
+        </CardContent>
+      </Card>
+
+      {/* 페이지네이션 - 데스크톱에서만 표시 */}
+      {pagination.totalPages > 1 && (
+        <div className="hidden xl:flex items-center justify-between">
+          <div className="text-sm text-muted-foreground">
+            전체 {pagination.totalItems}개 중 {startIndex + 1}-{Math.min(startIndex + pagination.itemsPerPage, pagination.totalItems)}개 표시
+          </div>
+          <div className="flex items-center gap-2">
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={() => pagination.onPageChange(pagination.currentPage - 1)}
+              disabled={pagination.currentPage === 1}
+            >
+              이전
+            </Button>
+            <div className="flex items-center gap-1">
+              {Array.from({ length: pagination.totalPages }, (_, i) => i + 1).map((page) => {
+                // 현재 페이지 근처만 표시
+                if (
+                  page === 1 ||
+                  page === pagination.totalPages ||
+                  (page >= pagination.currentPage - 2 && page <= pagination.currentPage + 2)
+                ) {
+                  return (
+                    <Button
+                      key={page}
+                      variant={page === pagination.currentPage ? "default" : "outline"}
+                      size="sm"
+                      onClick={() => pagination.onPageChange(page)}
+                      className="min-w-[36px]"
+                    >
+                      {page}
+                    </Button>
+                  );
+                } else if (
+                  page === pagination.currentPage - 3 ||
+                  page === pagination.currentPage + 3
+                ) {
+                  return <span key={page} className="px-2">...</span>;
+                }
+                return null;
+              })}
+            </div>
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={() => pagination.onPageChange(pagination.currentPage + 1)}
+              disabled={pagination.currentPage === pagination.totalPages}
+            >
+              다음
+            </Button>
+          </div>
+        </div>
+      )}
+
+      {/* 일괄 삭제 확인 다이얼로그 */}
+      <Dialog open={showDeleteDialog} onOpenChange={setShowDeleteDialog}>
+        <DialogContent className="sm:max-w-[425px]">
+          <DialogHeader>
+            <DialogTitle>일괄 삭제 확인</DialogTitle>
+            <DialogDescription>
+              선택된 항목을 삭제하시겠습니까? 이 작업은 되돌릴 수 없습니다.
+            </DialogDescription>
+          </DialogHeader>
+          <DialogFooter>
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={() => setShowDeleteDialog(false)}
+            >
+              취소
+            </Button>
+            <Button
+              variant="destructive"
+              size="sm"
+              onClick={handleConfirmDelete}
+            >
+              삭제
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </PageLayout>
+  );
+}
\ No newline at end of file
diff --git a/src/components/templates/ListPageTemplate.tsx b/src/components/templates/ListPageTemplate.tsx
new file mode 100644
index 00000000..9d36626d
--- /dev/null
+++ b/src/components/templates/ListPageTemplate.tsx
@@ -0,0 +1,144 @@
+"use client";
+
+import { ReactNode } from "react";
+import { LucideIcon } from "lucide-react";
+import { PageLayout } from "@/components/organisms/PageLayout";
+import { PageHeader } from "@/components/organisms/PageHeader";
+import { SearchFilter } from "@/components/organisms/SearchFilter";
+import { StatCards } from "@/components/organisms/StatCards";
+import { DataTable, Column } from "@/components/organisms/DataTable";
+import { EmptyState } from "@/components/organisms/EmptyState";
+import { MobileCard } from "@/components/organisms/MobileCard";
+
+interface ListPageTemplateProps<T> {
+  // Header
+  title: string;
+  description?: string;
+  icon?: LucideIcon;
+  actions?: ReactNode;
+
+  // Stats
+  stats?: Array<{
+    label: string;
+    value: string | number;
+    icon: LucideIcon;
+    iconColor?: string;
+    trend?: { value: string; isPositive: boolean };
+  }>;
+
+  // Search & Filter
+  searchValue: string;
+  onSearchChange: (value: string) => void;
+  searchPlaceholder?: string;
+  filterButton?: boolean;
+  onFilterClick?: () => void;
+  extraActions?: ReactNode;
+
+  // Data
+  data: T[];
+  keyField: keyof T;
+  loading?: boolean;
+
+  // Table
+  columns: Column<T>[];
+  onRowClick?: (row: T) => void;
+
+  // Mobile
+  renderMobileCard: (item: T) => {
+    title: string;
+    subtitle?: string;
+    icon?: ReactNode;
+    badge?: { label: string; variant?: "default" | "secondary" | "destructive" | "outline" };
+    fields: Array<{ label: string; value: string; badge?: boolean; badgeVariant?: string }>;
+    actions?: Array<{ label: string; onClick: () => void; icon?: ReactNode; variant?: "default" | "outline" | "destructive" }>;
+  };
+
+  // Empty State
+  emptyIcon?: LucideIcon;
+  emptyTitle?: string;
+  emptyDescription?: string;
+  emptyAction?: { label: string; onClick: () => void };
+
+  // Pagination
+  pagination?: {
+    currentPage: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+  };
+}
+
+export function ListPageTemplate<T>({
+  title,
+  description,
+  icon,
+  actions,
+  stats,
+  searchValue,
+  onSearchChange,
+  searchPlaceholder,
+  filterButton,
+  onFilterClick,
+  extraActions,
+  data,
+  keyField,
+  loading,
+  columns,
+  onRowClick,
+  renderMobileCard,
+  emptyIcon,
+  emptyTitle,
+  emptyDescription,
+  emptyAction,
+  pagination
+}: ListPageTemplateProps<T>) {
+  const isEmpty = !loading && data.length === 0;
+
+  return (
+    <PageLayout>
+      <PageHeader
+        title={title}
+        description={description}
+        icon={icon}
+        actions={actions}
+      />
+
+      {stats && <StatCards stats={stats} />}
+
+      <SearchFilter
+        searchValue={searchValue}
+        onSearchChange={onSearchChange}
+        searchPlaceholder={searchPlaceholder}
+        filterButton={filterButton}
+        onFilterClick={onFilterClick}
+        extraActions={extraActions}
+      />
+
+      {isEmpty ? (
+        <EmptyState
+          icon={emptyIcon || icon}
+          title={emptyTitle || `${title} 데이터가 없습니다`}
+          description={emptyDescription}
+          action={emptyAction}
+        />
+      ) : (
+        <>
+          <DataTable
+            columns={columns}
+            data={data}
+            keyField={keyField}
+            onRowClick={onRowClick}
+            loading={loading}
+            pagination={pagination}
+          />
+
+          <div className="md:hidden space-y-3">
+            {data.map((item) => {
+              const cardProps = renderMobileCard(item);
+              return <MobileCard key={String(item[keyField])} {...cardProps} />;
+            })}
+          </div>
+        </>
+      )}
+    </PageLayout>
+  );
+}
\ No newline at end of file
diff --git a/src/components/templates/index.ts b/src/components/templates/index.ts
new file mode 100644
index 00000000..04684e35
--- /dev/null
+++ b/src/components/templates/index.ts
@@ -0,0 +1,11 @@
+export { ListPageTemplate } from "./ListPageTemplate";
+export { IntegratedListTemplateV2 } from "./IntegratedListTemplateV2";
+export type {
+  TabOption,
+  TableColumn,
+  PaginationConfig,
+  StatCard,
+  VersionHistoryItem,
+  DevMetadata,
+  IntegratedListTemplateV2Props,
+} from "./IntegratedListTemplateV2";
\ No newline at end of file
diff --git a/src/components/ui/select.tsx b/src/components/ui/select.tsx
index 97c75fb2..fa1b26af 100644
--- a/src/components/ui/select.tsx
+++ b/src/components/ui/select.tsx
@@ -13,7 +13,8 @@ import { cn } from "@/lib/utils";
 function Select({
   ...props
 }: React.ComponentProps<typeof SelectPrimitive.Root>) {
-  return <SelectPrimitive.Root data-slot="select" {...props} />;
+  // modal={false}로 설정하여 aria-hidden 충돌 방지
+  return <SelectPrimitive.Root data-slot="select" modal={false} {...props} />;
 }
 
 function SelectGroup({
diff --git a/src/components/ui/separator.tsx b/src/components/ui/separator.tsx
new file mode 100644
index 00000000..001aae8b
--- /dev/null
+++ b/src/components/ui/separator.tsx
@@ -0,0 +1,31 @@
+"use client";
+
+import * as React from "react";
+import { cn } from "@/lib/utils";
+
+interface SeparatorProps extends React.HTMLAttributes<HTMLDivElement> {
+  orientation?: "horizontal" | "vertical";
+  decorative?: boolean;
+}
+
+const Separator = React.forwardRef<HTMLDivElement, SeparatorProps>(
+  (
+    { className, orientation = "horizontal", decorative = true, ...props },
+    ref
+  ) => (
+    <div
+      ref={ref}
+      role={decorative ? "none" : "separator"}
+      aria-orientation={decorative ? undefined : orientation}
+      className={cn(
+        "shrink-0 bg-border",
+        orientation === "horizontal" ? "h-[1px] w-full" : "h-full w-[1px]",
+        className
+      )}
+      {...props}
+    />
+  )
+);
+Separator.displayName = "Separator";
+
+export { Separator };
diff --git a/src/components/ui/sheet.tsx b/src/components/ui/sheet.tsx
index 318f426e..e6f643f9 100644
--- a/src/components/ui/sheet.tsx
+++ b/src/components/ui/sheet.tsx
@@ -7,7 +7,10 @@ import { XIcon } from "lucide-react";
 import { cn } from "./utils";
 
 function Sheet({ ...props }: React.ComponentProps<typeof SheetPrimitive.Root>) {
-  return <SheetPrimitive.Root data-slot="sheet" {...props} />;
+  // modal={false}: aria-hidden이 sibling 요소에 설정되지 않도록 함
+  // 사이드바 용도로는 modal 모드가 필요하지 않음 (focus trap 불필요)
+  // 이렇게 하면 Select, Dialog 등 다른 Radix 컴포넌트와 충돌 방지
+  return <SheetPrimitive.Root data-slot="sheet" modal={false} {...props} />;
 }
 
 function SheetTrigger({
diff --git a/src/contexts/ItemMasterContext.tsx b/src/contexts/ItemMasterContext.tsx
index 136ea267..f69b19c3 100644
--- a/src/contexts/ItemMasterContext.tsx
+++ b/src/contexts/ItemMasterContext.tsx
@@ -4,7 +4,7 @@ import { createContext, useContext, useState, useEffect, useMemo, ReactNode } fr
 import { useAuth } from './AuthContext';
 import { TenantAwareCache } from '@/lib/cache';
 import { itemMasterApi } from '@/lib/api/item-master';
-import { getErrorMessage } from '@/lib/api/error-handler';
+import { getErrorMessage, ApiError } from '@/lib/api/error-handler';
 import {
   transformPageResponse,
   transformSectionResponse,
@@ -1850,48 +1850,79 @@ export function ItemMasterProvider({ children }: { children: ReactNode }) {
 
   const reorderFields = async (sectionId: number, fieldIds: number[]) => {
     try {
-      // API 호출
-      const response = await itemMasterApi.fields.reorder(sectionId, {
-        field_orders: fieldIds.map((id, index) => ({ id, order_no: index + 1 }))  // order_no는 1부터 시작
-      });
+      // 2025-12-03: 검증 추가 - 빈 배열이면 스킵
+      if (!fieldIds || fieldIds.length === 0) {
+        console.warn('[ItemMasterContext] reorderFields 스킵: 필드 ID 배열이 비어있음');
+        return;
+      }
 
-      if (!response.success || !response.data) {
+      // 2025-12-03: 검증 추가 - 유효하지 않은 ID 필터링 (null, undefined, NaN 제거)
+      const validFieldIds = fieldIds.filter(id => id !== null && id !== undefined && !isNaN(id));
+      if (validFieldIds.length !== fieldIds.length) {
+        console.warn('[ItemMasterContext] reorderFields: 유효하지 않은 필드 ID 제거됨', {
+          original: fieldIds,
+          valid: validFieldIds
+        });
+      }
+
+      if (validFieldIds.length === 0) {
+        console.warn('[ItemMasterContext] reorderFields 스킵: 유효한 필드 ID가 없음');
+        return;
+      }
+
+      // 요청 데이터 구성 (2025-12-03: field_orders → items로 변경, 백엔드와 동일하게)
+      const requestData = {
+        items: validFieldIds.map((id, index) => ({ id, order_no: index + 1 }))  // order_no는 1부터 시작
+      };
+
+      // API 호출
+      const response = await itemMasterApi.fields.reorder(sectionId, requestData);
+
+      if (!response.success) {
         throw new Error(response.message || '필드 순서 변경 실패');
       }
 
-      // 응답 데이터 변환 및 state 업데이트
-      const reorderedFields = response.data.map(fieldResponse => ({
-        id: fieldResponse.id,
-        tenant_id: fieldResponse.tenant_id,
-        section_id: fieldResponse.section_id,
-        master_field_id: fieldResponse.master_field_id ?? null, // optional 처리
-        field_name: fieldResponse.field_name,
-        field_type: fieldResponse.field_type,
-        order_no: fieldResponse.order_no,
-        is_required: fieldResponse.is_required,
-        default_value: fieldResponse.default_value,
-        placeholder: fieldResponse.placeholder,
-        display_condition: fieldResponse.display_condition,
-        validation_rules: fieldResponse.validation_rules,
-        options: fieldResponse.options,
-        properties: fieldResponse.properties,
-        created_at: fieldResponse.created_at,
-        updated_at: fieldResponse.updated_at,
-      }));
-
+      // 2025-12-03: 백엔드가 'success' 문자열만 반환하므로 로컬 state에서 순서 업데이트
+      // validFieldIds 순서대로 필드 재정렬
       setItemPages(prev => prev.map(page => ({
         ...page,
-        sections: page.sections.map(section =>
-          section.id === sectionId
-            ? { ...section, fields: reorderedFields }
-            : section
-        )
+        sections: page.sections.map(section => {
+          if (section.id !== sectionId) return section;
+
+          // fieldIds 순서대로 필드 재정렬
+          const fieldMap = new Map((section.fields || []).map(f => [f.id, f]));
+          const reorderedFields = validFieldIds
+            .map((id, index) => {
+              const field = fieldMap.get(id);
+              return field ? { ...field, order_no: index + 1 } : null;
+            })
+            .filter((f): f is ItemField => f !== null);
+
+          return { ...section, fields: reorderedFields };
+        })
       })));
 
-      console.log('[ItemMasterContext] 필드 순서 변경 성공');
+      // 2025-12-03: 섹션탭 실시간 반영 추가
+      setIndependentSections(prev => prev.map(section => {
+        if (section.id !== sectionId) return section;
+
+        const fieldMap = new Map((section.fields || []).map(f => [f.id, f]));
+        const reorderedFields = validFieldIds
+          .map((id, index) => {
+            const field = fieldMap.get(id);
+            return field ? { ...field, order_no: index + 1 } : null;
+          })
+          .filter((f): f is ItemField => f !== null);
+
+        return { ...section, fields: reorderedFields };
+      }));
     } catch (error) {
       const errorMessage = getErrorMessage(error);
       console.error('[ItemMasterContext] 필드 순서 변경 실패:', errorMessage);
+      // 2025-12-03: ApiError인 경우 상세 정보 출력
+      if (error instanceof ApiError && error.errors) {
+        console.error('[ItemMasterContext] 상세 검증 에러:', error.errors);
+      }
       throw error;
     }
   };
@@ -2326,7 +2357,18 @@ export function ItemMasterProvider({ children }: { children: ReactNode }) {
           ...page,
           sections: page.sections.map(section =>
             section.id === sectionId
-              ? { ...section, fields: [...(section.fields || []), { ...linkedField, section_id: sectionId }] }
+              ? {
+                  ...section,
+                  fields: [
+                    ...(section.fields || []),
+                    {
+                      ...linkedField,
+                      section_id: sectionId,
+                      // 2025-12-02: 섹션별 순서 종속 - 새 order_no 할당
+                      order_no: orderNo ?? section.fields?.length ?? 0
+                    }
+                  ]
+                }
               : section
           )
         })));
@@ -2335,7 +2377,18 @@ export function ItemMasterProvider({ children }: { children: ReactNode }) {
         // sectionsAsTemplates useMemo가 [itemPages, independentSections] 둘 다 의존
         setIndependentSections(prev => prev.map(section =>
           section.id === sectionId
-            ? { ...section, fields: [...(section.fields || []), { ...linkedField, section_id: sectionId }] }
+            ? {
+                ...section,
+                fields: [
+                  ...(section.fields || []),
+                  {
+                    ...linkedField,
+                    section_id: sectionId,
+                    // 2025-12-02: 섹션별 순서 종속 - 새 order_no 할당
+                    order_no: orderNo ?? section.fields?.length ?? 0
+                  }
+                ]
+              }
             : section
         ));
       }
diff --git a/src/hooks/useItemList.ts b/src/hooks/useItemList.ts
new file mode 100644
index 00000000..1f1ea8ad
--- /dev/null
+++ b/src/hooks/useItemList.ts
@@ -0,0 +1,326 @@
+/**
+ * 품목 목록 및 테이블 컬럼 관리 훅
+ *
+ * - 품목 목록 API 조회 (서버 사이드 검색/필터링)
+ * - custom-tabs 기반 동적 테이블 컬럼
+ */
+
+'use client';
+
+import { useState, useEffect, useCallback, useRef } from 'react';
+import type { ItemMaster } from '@/types/item';
+import type { CustomTabResponse, TabColumnResponse } from '@/types/item-master-api';
+import { itemMasterApi } from '@/lib/api/item-master';
+
+// 기본 테이블 컬럼 설정 (API 응답 실패 시 폴백용)
+const defaultTableColumns = [
+  { key: 'item_code', label: '품목코드', visible: true, order: 0 },
+  { key: 'item_type', label: '품목유형', visible: true, order: 1 },
+  { key: 'item_name', label: '품목명', visible: true, order: 2 },
+  { key: 'specification', label: '규격', visible: true, order: 3 },
+  { key: 'unit', label: '단위', visible: true, order: 4 },
+  { key: 'is_active', label: '상태', visible: true, order: 5 },
+];
+
+export interface TableColumn {
+  key: string;
+  label: string;
+  visible: boolean;
+  order: number;
+}
+
+export interface ItemListFilters {
+  search?: string;
+  type?: string;
+  page?: number;
+  size?: number;
+}
+
+export interface PaginationInfo {
+  currentPage: number;
+  totalPages: number;
+  totalItems: number;
+  perPage: number;
+}
+
+export interface ItemStats {
+  total: number;
+  byType: Record<string, number>;
+}
+
+export interface TotalStats {
+  totalAll: number;      // 전체 품목 수 (필터 무관)
+  totalFG: number;       // 제품 수
+  totalPT: number;       // 부품 수
+  totalSM: number;       // 부자재 수
+  totalRM: number;       // 원자재 수
+  totalCS: number;       // 소모품 수
+}
+
+export interface UseItemListResult {
+  // 데이터
+  items: ItemMaster[];
+  tabs: CustomTabResponse[];
+  columns: TableColumn[];
+  pagination: PaginationInfo;
+  totalStats: TotalStats;  // 필터 무관한 전체 통계
+
+  // 상태
+  isLoading: boolean;
+  isSearching: boolean;
+  error: string | null;
+
+  // 액션
+  refresh: () => Promise<void>;
+  search: (filters: ItemListFilters) => Promise<void>;
+  setActiveTab: (tabId: number | null) => void;
+  activeTabId: number | null;
+}
+
+export function useItemList(): UseItemListResult {
+  // 데이터 상태
+  const [items, setItems] = useState<ItemMaster[]>([]);
+  const [tabs, setTabs] = useState<CustomTabResponse[]>([]);
+  const [tabColumns, setTabColumns] = useState<Record<number, TabColumnResponse[]>>({});
+  const [pagination, setPagination] = useState<PaginationInfo>({
+    currentPage: 1,
+    totalPages: 1,
+    totalItems: 0,
+    perPage: 20,
+  });
+
+  // 전체 통계 (필터와 무관하게 유지)
+  const [totalStats, setTotalStats] = useState<TotalStats>({
+    totalAll: 0,
+    totalFG: 0,
+    totalPT: 0,
+    totalSM: 0,
+    totalRM: 0,
+    totalCS: 0,
+  });
+
+  // UI 상태
+  const [activeTabId, setActiveTabId] = useState<number | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [isSearching, setIsSearching] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // 현재 필터 상태 (ref로 관리하여 불필요한 리렌더링 방지)
+  const currentFilters = useRef<ItemListFilters>({});
+
+  // 현재 탭의 컬럼 설정
+  const columns: TableColumn[] = activeTabId && tabColumns[activeTabId]
+    ? tabColumns[activeTabId].map((col, idx) => ({
+        key: col.key,
+        label: col.label,
+        visible: col.visible,
+        order: col.order ?? idx,
+      }))
+    : defaultTableColumns;
+
+  // API 응답을 프론트엔드 타입으로 변환하는 함수
+  const mapItemResponse = (item: Record<string, unknown>): ItemMaster => {
+    // 디버깅: API 응답에서 id 필드 확인
+    const itemId = item.id ?? item.item_id ?? item.ID;
+    if (!itemId) {
+      console.warn('[useItemList] id 필드 누락:', {
+        availableKeys: Object.keys(item),
+        item
+      });
+    }
+
+    return {
+    id: String(itemId ?? ''),
+    itemCode: (item.code ?? item.item_code ?? '') as string,
+    itemName: (item.name ?? item.item_name ?? '') as string,
+    itemType: (item.type_code ?? item.item_type ?? '') as string,
+    partType: item.part_type as string | undefined,
+    unit: (item.unit ?? '') as string,
+    specification: (item.specification ?? '') as string,
+    isActive: item.is_active !== undefined ? Boolean(item.is_active) : (item.deleted_at === null),
+    category1: (item.category1 ?? '') as string,
+    category2: (item.category2 ?? '') as string,
+    category3: (item.category3 ?? '') as string,
+    salesPrice: (item.sales_price ?? 0) as number,
+    purchasePrice: (item.purchase_price ?? 0) as number,
+    currentRevision: (item.current_revision ?? 0) as number,
+    createdAt: (item.created_at ?? '') as string,
+    updatedAt: (item.updated_at ?? '') as string,
+  };
+  };
+
+  // 전체 통계 조회 (필터 없이 전체 데이터 기준)
+  const fetchTotalStats = useCallback(async () => {
+    try {
+      // 각 유형별로 병렬 조회
+      const [allResponse, fgResponse, ptResponse, smResponse, rmResponse, csResponse] = await Promise.all([
+        fetch('/api/proxy/items?size=1'),           // 전체 (size=1로 최소 데이터만)
+        fetch('/api/proxy/items?type=FG&size=1'),   // 제품
+        fetch('/api/proxy/items?type=PT&size=1'),   // 부품
+        fetch('/api/proxy/items?type=SM&size=1'),   // 부자재
+        fetch('/api/proxy/items?type=RM&size=1'),   // 원자재
+        fetch('/api/proxy/items?type=CS&size=1'),   // 소모품
+      ]);
+
+      const [allResult, fgResult, ptResult, smResult, rmResult, csResult] = await Promise.all([
+        allResponse.json(),
+        fgResponse.json(),
+        ptResponse.json(),
+        smResponse.json(),
+        rmResponse.json(),
+        csResponse.json(),
+      ]);
+
+      return {
+        totalAll: allResult.data?.total ?? 0,
+        totalFG: fgResult.data?.total ?? 0,
+        totalPT: ptResult.data?.total ?? 0,
+        totalSM: smResult.data?.total ?? 0,
+        totalRM: rmResult.data?.total ?? 0,
+        totalCS: csResult.data?.total ?? 0,
+      };
+    } catch (err) {
+      console.error('전체 통계 조회 실패:', err);
+      return { totalAll: 0, totalFG: 0, totalPT: 0, totalSM: 0, totalRM: 0, totalCS: 0 };
+    }
+  }, []);
+
+  // 품목 목록 조회 (필터 적용)
+  const fetchItems = useCallback(async (filters: ItemListFilters = {}) => {
+    // URL 쿼리 파라미터 생성
+    const params = new URLSearchParams();
+
+    if (filters.search && filters.search.trim()) {
+      params.append('search', filters.search.trim());
+    }
+    if (filters.type && filters.type !== 'all') {
+      params.append('type', filters.type);
+    }
+    if (filters.page) {
+      params.append('page', String(filters.page));
+    }
+    if (filters.size) {
+      params.append('size', String(filters.size));
+    }
+
+    const queryString = params.toString();
+    const url = `/api/proxy/items${queryString ? `?${queryString}` : ''}`;
+
+    const itemsResponse = await fetch(url);
+    const itemsResult = await itemsResponse.json();
+
+    if (itemsResult.success) {
+      // API 응답 구조: { success, data: { data: [...], current_page, total, per_page, last_page } }
+      const paginatedData = itemsResult.data;
+      const rawItems = paginatedData?.data ?? paginatedData ?? [];
+
+      if (!Array.isArray(rawItems)) {
+        return { items: [], pagination: { currentPage: 1, totalPages: 1, totalItems: 0, perPage: 20 } };
+      }
+
+      const mappedItems = rawItems.map(mapItemResponse);
+
+      return {
+        items: mappedItems,
+        pagination: {
+          currentPage: paginatedData?.current_page ?? 1,
+          totalPages: paginatedData?.last_page ?? 1,
+          totalItems: paginatedData?.total ?? mappedItems.length,
+          perPage: paginatedData?.per_page ?? 20,
+        },
+      };
+    } else {
+      throw new Error(itemsResult.message || '품목 목록을 불러올 수 없습니다.');
+    }
+  }, []);
+
+  // 초기 데이터 로드
+  const loadData = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      // 1. 품목기준관리 init API 호출 (탭 + 컬럼 설정 포함)
+      const initData = await itemMasterApi.init();
+
+      if (initData.customTabs) {
+        setTabs(initData.customTabs);
+
+        // 기본 탭 설정
+        const defaultTab = initData.customTabs.find((t) => t.is_default);
+        if (defaultTab) {
+          setActiveTabId(defaultTab.id);
+        } else if (initData.customTabs.length > 0) {
+          setActiveTabId(initData.customTabs[0].id);
+        }
+      }
+
+      if (initData.tabColumns) {
+        setTabColumns(initData.tabColumns);
+      }
+
+      // 2. 품목 목록 API 호출 + 전체 통계 병렬 조회
+      const [result, stats] = await Promise.all([
+        fetchItems(currentFilters.current),
+        fetchTotalStats(),
+      ]);
+      setItems(result.items);
+      setPagination(result.pagination);
+      setTotalStats(stats);
+    } catch (err) {
+      console.error('품목 목록 로드 실패:', err);
+
+      // API 실패 시 에러만 표시
+      setItems([]);
+      setTabs([]);
+      setTabColumns({});
+      setPagination({ currentPage: 1, totalPages: 1, totalItems: 0, perPage: 20 });
+      setError(err instanceof Error ? err.message : '데이터 로드 실패');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [fetchItems, fetchTotalStats]);
+
+  // 검색/필터 적용
+  const search = useCallback(async (filters: ItemListFilters) => {
+    setIsSearching(true);
+    setError(null);
+    currentFilters.current = { ...currentFilters.current, ...filters };
+
+    try {
+      const result = await fetchItems(currentFilters.current);
+      setItems(result.items);
+      setPagination(result.pagination);
+    } catch (err) {
+      console.error('품목 검색 실패:', err);
+      setError(err instanceof Error ? err.message : '검색 실패');
+    } finally {
+      setIsSearching(false);
+    }
+  }, [fetchItems]);
+
+  // 초기 로드
+  useEffect(() => {
+    loadData();
+  }, [loadData]);
+
+  // 탭 변경
+  const setActiveTab = useCallback((tabId: number | null) => {
+    setActiveTabId(tabId);
+  }, []);
+
+  return {
+    items,
+    tabs,
+    columns,
+    pagination,
+    totalStats,
+    isLoading,
+    isSearching,
+    error,
+    refresh: loadData,
+    search,
+    setActiveTab,
+    activeTabId,
+  };
+}
\ No newline at end of file
diff --git a/src/layouts/DashboardLayout.tsx b/src/layouts/DashboardLayout.tsx
index 1d602faa..7ccbe4c8 100644
--- a/src/layouts/DashboardLayout.tsx
+++ b/src/layouts/DashboardLayout.tsx
@@ -14,6 +14,11 @@ import {
   Sun,
   Moon,
   Accessibility,
+  ShoppingCart,
+  Building2,
+  Receipt,
+  Package,
+  Settings,
 } from 'lucide-react';
 import { Input } from '@/components/ui/input';
 import { Button } from '@/components/ui/button';
@@ -38,8 +43,8 @@ export default function DashboardLayout({ children }: DashboardLayoutProps) {
   const router = useRouter();
   const pathname = usePathname(); // 현재 경로 추적
 
-  // 확장된 서브메뉴 관리 (기본적으로 master-data 확장)
-  const [expandedMenus, setExpandedMenus] = useState<string[]>(['master-data']);
+  // 확장된 서브메뉴 관리 (기본적으로 sales, master-data 확장)
+  const [expandedMenus, setExpandedMenus] = useState<string[]>(['sales', 'master-data']);
 
   // 모바일 상태 관리
   const [isMobile, setIsMobile] = useState(false);
@@ -81,8 +86,27 @@ export default function DashboardLayout({ children }: DashboardLayoutProps) {
         setMenuItems(deserializedMenus);
       } else {
         // API가 준비될 때까지 임시 기본 메뉴
-        const defaultMenu = [
+        const defaultMenu: MenuItem[] = [
           { id: "dashboard", label: "대시보드", icon: LayoutDashboard, path: "/dashboard" },
+          {
+            id: "sales",
+            label: "판매관리",
+            icon: ShoppingCart,
+            path: "#",
+            children: [
+              { id: "customer-management", label: "거래처관리", icon: Building2, path: "/sales/client-management-sales-admin" },
+              { id: "quote-management", label: "견적관리", icon: Receipt, path: "/sales/quote-management" },
+            ],
+          },
+          {
+            id: "master-data",
+            label: "기준정보",
+            icon: Settings,
+            path: "#",
+            children: [
+              { id: "item-master", label: "품목기준관리", icon: Package, path: "/master-data/item-master-data-management" },
+            ],
+          },
         ];
         setMenuItems(defaultMenu);
       }
diff --git a/src/lib/utils/menuTransform.ts b/src/lib/utils/menuTransform.ts
index 29536880..87274b0f 100644
--- a/src/lib/utils/menuTransform.ts
+++ b/src/lib/utils/menuTransform.ts
@@ -9,6 +9,9 @@ import {
   Users,
   Lock,
   Building,
+  ShoppingCart,
+  Receipt,
+  Factory,
   LucideIcon,
 } from 'lucide-react';
 
@@ -23,6 +26,15 @@ export const iconMap: Record<string, LucideIcon> = {
   people: Users,
   lock: Lock,
   corporate_fare: Building,
+  // 판매관리 관련 아이콘
+  shopping_cart: ShoppingCart,
+  sales: ShoppingCart,
+  receipt: Receipt,
+  quote: Receipt,
+  customers: Building2,
+  // 생산관리 관련 아이콘
+  factory: Factory,
+  production: Factory,
 };
 
 // API 메뉴 데이터 타입
diff --git a/src/types/item-master-api.ts b/src/types/item-master-api.ts
index a18aeceb..6bb51f9e 100644
--- a/src/types/item-master-api.ts
+++ b/src/types/item-master-api.ts
@@ -250,9 +250,10 @@ export interface ItemFieldResponse {
 /**
  * 필드 순서 변경 요청
  * PUT /v1/item-master/sections/{sectionId}/fields/reorder
+ * 백엔드 API는 'items' 필드를 기대함 (SectionReorderRequest와 동일)
  */
 export interface FieldReorderRequest {
-  field_orders: Array<{
+  items: Array<{
     id: number;
     order_no: number;
   }>;
diff --git a/src/utils/formatAmount.ts b/src/utils/formatAmount.ts
new file mode 100644
index 00000000..f4c8ddc1
--- /dev/null
+++ b/src/utils/formatAmount.ts
@@ -0,0 +1,30 @@
+/**
+ * 금액 포맷팅 유틸리티
+ *
+ * 1만원 미만: "1,000원"
+ * 1만원 이상: "1,000만원"
+ */
+
+export function formatAmount(amount: number): string {
+  if (amount < 10000) {
+    return `${amount.toLocaleString("ko-KR")}원`;
+  } else {
+    const manwon = Math.round(amount / 10000);
+    return `${manwon.toLocaleString("ko-KR")}만원`;
+  }
+}
+
+/**
+ * 금액을 원 단위로 포맷 (항상 "원" 단위)
+ */
+export function formatAmountWon(amount: number): string {
+  return `${amount.toLocaleString("ko-KR")}원`;
+}
+
+/**
+ * 금액을 만원 단위로 포맷 (항상 "만원" 단위)
+ */
+export function formatAmountManwon(amount: number): string {
+  const manwon = Math.round(amount / 10000);
+  return `${manwon.toLocaleString("ko-KR")}만원`;
+}
\ No newline at end of file
diff --git a/tsconfig.tsbuildinfo b/tsconfig.tsbuildinfo
index 1b944aa7..41ce5183 100644
--- a/tsconfig.tsbuildinfo
+++ b/tsconfig.tsbuildinfo
@@ -1 +1 @@
-{"fileNames":["./node_modules/typescript/lib/lib.es5.d.ts","./node_modules/typescript/lib/lib.es2015.d.ts","./node_modules/typescript/lib/lib.es2016.d.ts","./node_modules/typescript/lib/lib.es2017.d.ts","./node_modules/typescript/lib/lib.es2018.d.ts","./node_modules/typescript/lib/lib.es2019.d.ts","./node_modules/typescript/lib/lib.es2020.d.ts","./node_modules/typescript/lib/lib.es2021.d.ts","./node_modules/typescript/lib/lib.es2022.d.ts","./node_modules/typescript/lib/lib.es2023.d.ts","./node_modules/typescript/lib/lib.es2024.d.ts","./node_modules/typescript/lib/lib.esnext.d.ts","./node_modules/typescript/lib/lib.dom.d.ts","./node_modules/typescript/lib/lib.dom.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.core.d.ts","./node_modules/typescript/lib/lib.es2015.collection.d.ts","./node_modules/typescript/lib/lib.es2015.generator.d.ts","./node_modules/typescript/lib/lib.es2015.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.promise.d.ts","./node_modules/typescript/lib/lib.es2015.proxy.d.ts","./node_modules/typescript/lib/lib.es2015.reflect.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2016.array.include.d.ts","./node_modules/typescript/lib/lib.es2016.intl.d.ts","./node_modules/typescript/lib/lib.es2017.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2017.date.d.ts","./node_modules/typescript/lib/lib.es2017.object.d.ts","./node_modules/typescript/lib/lib.es2017.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2017.string.d.ts","./node_modules/typescript/lib/lib.es2017.intl.d.ts","./node_modules/typescript/lib/lib.es2017.typedarrays.d.ts","./node_modules/typescript/lib/lib.es2018.asyncgenerator.d.ts","./node_modules/typescript/lib/lib.es2018.asynciterable.d.ts","./node_modules/typescript/lib/lib.es2018.intl.d.ts","./node_modules/typescript/lib/lib.es2018.promise.d.ts","./node_modules/typescript/lib/lib.es2018.regexp.d.ts","./node_modules/typescript/lib/lib.es2019.array.d.ts","./node_modules/typescript/lib/lib.es2019.object.d.ts","./node_modules/typescript/lib/lib.es2019.string.d.ts","./node_modules/typescript/lib/lib.es2019.symbol.d.ts","./node_modules/typescript/lib/lib.es2019.intl.d.ts","./node_modules/typescript/lib/lib.es2020.bigint.d.ts","./node_modules/typescript/lib/lib.es2020.date.d.ts","./node_modules/typescript/lib/lib.es2020.promise.d.ts","./node_modules/typescript/lib/lib.es2020.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2020.string.d.ts","./node_modules/typescript/lib/lib.es2020.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2020.intl.d.ts","./node_modules/typescript/lib/lib.es2020.number.d.ts","./node_modules/typescript/lib/lib.es2021.promise.d.ts","./node_modules/typescript/lib/lib.es2021.string.d.ts","./node_modules/typescript/lib/lib.es2021.weakref.d.ts","./node_modules/typescript/lib/lib.es2021.intl.d.ts","./node_modules/typescript/lib/lib.es2022.array.d.ts","./node_modules/typescript/lib/lib.es2022.error.d.ts","./node_modules/typescript/lib/lib.es2022.intl.d.ts","./node_modules/typescript/lib/lib.es2022.object.d.ts","./node_modules/typescript/lib/lib.es2022.string.d.ts","./node_modules/typescript/lib/lib.es2022.regexp.d.ts","./node_modules/typescript/lib/lib.es2023.array.d.ts","./node_modules/typescript/lib/lib.es2023.collection.d.ts","./node_modules/typescript/lib/lib.es2023.intl.d.ts","./node_modules/typescript/lib/lib.es2024.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2024.collection.d.ts","./node_modules/typescript/lib/lib.es2024.object.d.ts","./node_modules/typescript/lib/lib.es2024.promise.d.ts","./node_modules/typescript/lib/lib.es2024.regexp.d.ts","./node_modules/typescript/lib/lib.es2024.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2024.string.d.ts","./node_modules/typescript/lib/lib.esnext.array.d.ts","./node_modules/typescript/lib/lib.esnext.collection.d.ts","./node_modules/typescript/lib/lib.esnext.intl.d.ts","./node_modules/typescript/lib/lib.esnext.disposable.d.ts","./node_modules/typescript/lib/lib.esnext.promise.d.ts","./node_modules/typescript/lib/lib.esnext.decorators.d.ts","./node_modules/typescript/lib/lib.esnext.iterator.d.ts","./node_modules/typescript/lib/lib.esnext.float16.d.ts","./node_modules/typescript/lib/lib.esnext.error.d.ts","./node_modules/typescript/lib/lib.esnext.sharedmemory.d.ts","./node_modules/typescript/lib/lib.decorators.d.ts","./node_modules/typescript/lib/lib.decorators.legacy.d.ts","./.next/types/routes.d.ts","./node_modules/@types/react/global.d.ts","./node_modules/csstype/index.d.ts","./node_modules/@types/react/index.d.ts","./node_modules/next/dist/styled-jsx/types/css.d.ts","./node_modules/next/dist/styled-jsx/types/macro.d.ts","./node_modules/next/dist/styled-jsx/types/style.d.ts","./node_modules/next/dist/styled-jsx/types/global.d.ts","./node_modules/next/dist/styled-jsx/types/index.d.ts","./node_modules/next/dist/shared/lib/amp.d.ts","./node_modules/next/amp.d.ts","./node_modules/next/dist/server/get-page-files.d.ts","./node_modules/@types/node/compatibility/disposable.d.ts","./node_modules/@types/node/compatibility/indexable.d.ts","./node_modules/@types/node/compatibility/iterators.d.ts","./node_modules/@types/node/compatibility/index.d.ts","./node_modules/@types/node/globals.typedarray.d.ts","./node_modules/@types/node/buffer.buffer.d.ts","./node_modules/@types/node/globals.d.ts","./node_modules/@types/node/web-globals/abortcontroller.d.ts","./node_modules/@types/node/web-globals/domexception.d.ts","./node_modules/@types/node/web-globals/events.d.ts","./node_modules/undici-types/header.d.ts","./node_modules/undici-types/readable.d.ts","./node_modules/undici-types/file.d.ts","./node_modules/undici-types/fetch.d.ts","./node_modules/undici-types/formdata.d.ts","./node_modules/undici-types/connector.d.ts","./node_modules/undici-types/client.d.ts","./node_modules/undici-types/errors.d.ts","./node_modules/undici-types/dispatcher.d.ts","./node_modules/undici-types/global-dispatcher.d.ts","./node_modules/undici-types/global-origin.d.ts","./node_modules/undici-types/pool-stats.d.ts","./node_modules/undici-types/pool.d.ts","./node_modules/undici-types/handlers.d.ts","./node_modules/undici-types/balanced-pool.d.ts","./node_modules/undici-types/agent.d.ts","./node_modules/undici-types/mock-interceptor.d.ts","./node_modules/undici-types/mock-agent.d.ts","./node_modules/undici-types/mock-client.d.ts","./node_modules/undici-types/mock-pool.d.ts","./node_modules/undici-types/mock-errors.d.ts","./node_modules/undici-types/proxy-agent.d.ts","./node_modules/undici-types/env-http-proxy-agent.d.ts","./node_modules/undici-types/retry-handler.d.ts","./node_modules/undici-types/retry-agent.d.ts","./node_modules/undici-types/api.d.ts","./node_modules/undici-types/interceptors.d.ts","./node_modules/undici-types/util.d.ts","./node_modules/undici-types/cookies.d.ts","./node_modules/undici-types/patch.d.ts","./node_modules/undici-types/websocket.d.ts","./node_modules/undici-types/eventsource.d.ts","./node_modules/undici-types/filereader.d.ts","./node_modules/undici-types/diagnostics-channel.d.ts","./node_modules/undici-types/content-type.d.ts","./node_modules/undici-types/cache.d.ts","./node_modules/undici-types/index.d.ts","./node_modules/@types/node/web-globals/fetch.d.ts","./node_modules/@types/node/assert.d.ts","./node_modules/@types/node/assert/strict.d.ts","./node_modules/@types/node/async_hooks.d.ts","./node_modules/@types/node/buffer.d.ts","./node_modules/@types/node/child_process.d.ts","./node_modules/@types/node/cluster.d.ts","./node_modules/@types/node/console.d.ts","./node_modules/@types/node/constants.d.ts","./node_modules/@types/node/crypto.d.ts","./node_modules/@types/node/dgram.d.ts","./node_modules/@types/node/diagnostics_channel.d.ts","./node_modules/@types/node/dns.d.ts","./node_modules/@types/node/dns/promises.d.ts","./node_modules/@types/node/domain.d.ts","./node_modules/@types/node/events.d.ts","./node_modules/@types/node/fs.d.ts","./node_modules/@types/node/fs/promises.d.ts","./node_modules/@types/node/http.d.ts","./node_modules/@types/node/http2.d.ts","./node_modules/@types/node/https.d.ts","./node_modules/@types/node/inspector.generated.d.ts","./node_modules/@types/node/module.d.ts","./node_modules/@types/node/net.d.ts","./node_modules/@types/node/os.d.ts","./node_modules/@types/node/path.d.ts","./node_modules/@types/node/perf_hooks.d.ts","./node_modules/@types/node/process.d.ts","./node_modules/@types/node/punycode.d.ts","./node_modules/@types/node/querystring.d.ts","./node_modules/@types/node/readline.d.ts","./node_modules/@types/node/readline/promises.d.ts","./node_modules/@types/node/repl.d.ts","./node_modules/@types/node/sea.d.ts","./node_modules/@types/node/stream.d.ts","./node_modules/@types/node/stream/promises.d.ts","./node_modules/@types/node/stream/consumers.d.ts","./node_modules/@types/node/stream/web.d.ts","./node_modules/@types/node/string_decoder.d.ts","./node_modules/@types/node/test.d.ts","./node_modules/@types/node/timers.d.ts","./node_modules/@types/node/timers/promises.d.ts","./node_modules/@types/node/tls.d.ts","./node_modules/@types/node/trace_events.d.ts","./node_modules/@types/node/tty.d.ts","./node_modules/@types/node/url.d.ts","./node_modules/@types/node/util.d.ts","./node_modules/@types/node/v8.d.ts","./node_modules/@types/node/vm.d.ts","./node_modules/@types/node/wasi.d.ts","./node_modules/@types/node/worker_threads.d.ts","./node_modules/@types/node/zlib.d.ts","./node_modules/@types/node/index.d.ts","./node_modules/@types/react/canary.d.ts","./node_modules/@types/react/experimental.d.ts","./node_modules/@types/react-dom/index.d.ts","./node_modules/@types/react-dom/canary.d.ts","./node_modules/@types/react-dom/experimental.d.ts","./node_modules/next/dist/lib/fallback.d.ts","./node_modules/next/dist/compiled/webpack/webpack.d.ts","./node_modules/next/dist/server/config.d.ts","./node_modules/next/dist/lib/load-custom-routes.d.ts","./node_modules/next/dist/shared/lib/image-config.d.ts","./node_modules/next/dist/build/webpack/plugins/subresource-integrity-plugin.d.ts","./node_modules/next/dist/server/body-streams.d.ts","./node_modules/next/dist/server/lib/cache-control.d.ts","./node_modules/next/dist/lib/setup-exception-listeners.d.ts","./node_modules/next/dist/lib/worker.d.ts","./node_modules/next/dist/lib/constants.d.ts","./node_modules/next/dist/client/components/app-router-headers.d.ts","./node_modules/next/dist/build/rendering-mode.d.ts","./node_modules/next/dist/server/lib/router-utils/build-prefetch-segment-data-route.d.ts","./node_modules/next/dist/server/require-hook.d.ts","./node_modules/next/dist/server/lib/experimental/ppr.d.ts","./node_modules/next/dist/build/webpack/plugins/app-build-manifest-plugin.d.ts","./node_modules/next/dist/lib/page-types.d.ts","./node_modules/next/dist/build/segment-config/app/app-segment-config.d.ts","./node_modules/next/dist/build/segment-config/pages/pages-segment-config.d.ts","./node_modules/next/dist/build/analysis/get-page-static-info.d.ts","./node_modules/next/dist/build/webpack/loaders/get-module-build-info.d.ts","./node_modules/next/dist/build/webpack/plugins/middleware-plugin.d.ts","./node_modules/next/dist/server/node-polyfill-crypto.d.ts","./node_modules/next/dist/server/node-environment-baseline.d.ts","./node_modules/next/dist/server/node-environment-extensions/error-inspect.d.ts","./node_modules/next/dist/server/node-environment-extensions/random.d.ts","./node_modules/next/dist/server/node-environment-extensions/date.d.ts","./node_modules/next/dist/server/node-environment-extensions/web-crypto.d.ts","./node_modules/next/dist/server/node-environment-extensions/node-crypto.d.ts","./node_modules/next/dist/server/node-environment.d.ts","./node_modules/next/dist/build/page-extensions-type.d.ts","./node_modules/next/dist/build/webpack/plugins/flight-manifest-plugin.d.ts","./node_modules/next/dist/server/instrumentation/types.d.ts","./node_modules/next/dist/lib/coalesced-function.d.ts","./node_modules/next/dist/shared/lib/router/utils/middleware-route-matcher.d.ts","./node_modules/next/dist/server/lib/router-utils/types.d.ts","./node_modules/next/dist/shared/lib/modern-browserslist-target.d.ts","./node_modules/next/dist/shared/lib/constants.d.ts","./node_modules/next/dist/trace/types.d.ts","./node_modules/next/dist/trace/trace.d.ts","./node_modules/next/dist/trace/shared.d.ts","./node_modules/next/dist/trace/index.d.ts","./node_modules/next/dist/build/load-jsconfig.d.ts","./node_modules/@next/env/dist/index.d.ts","./node_modules/next/dist/build/webpack/plugins/telemetry-plugin/use-cache-tracker-utils.d.ts","./node_modules/next/dist/build/webpack/plugins/telemetry-plugin/telemetry-plugin.d.ts","./node_modules/next/dist/telemetry/storage.d.ts","./node_modules/next/dist/build/build-context.d.ts","./node_modules/next/dist/shared/lib/bloom-filter.d.ts","./node_modules/next/dist/build/webpack-config.d.ts","./node_modules/next/dist/server/route-kind.d.ts","./node_modules/next/dist/server/route-definitions/route-definition.d.ts","./node_modules/next/dist/build/swc/generated-native.d.ts","./node_modules/next/dist/build/swc/types.d.ts","./node_modules/next/dist/server/dev/parse-version-info.d.ts","./node_modules/next/dist/next-devtools/shared/types.d.ts","./node_modules/next/dist/server/dev/dev-indicator-server-state.d.ts","./node_modules/next/dist/server/lib/parse-stack.d.ts","./node_modules/next/dist/next-devtools/server/shared.d.ts","./node_modules/next/dist/next-devtools/shared/stack-frame.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/utils/get-error-by-type.d.ts","./node_modules/@types/react/jsx-runtime.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/container/runtime-error/render-error.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/shared.d.ts","./node_modules/next/dist/server/dev/hot-reloader-types.d.ts","./node_modules/next/dist/server/lib/cache-handlers/types.d.ts","./node_modules/next/dist/server/response-cache/types.d.ts","./node_modules/next/dist/server/resume-data-cache/cache-store.d.ts","./node_modules/next/dist/server/resume-data-cache/resume-data-cache.d.ts","./node_modules/next/dist/server/render-result.d.ts","./node_modules/next/dist/server/lib/i18n-provider.d.ts","./node_modules/next/dist/server/web/next-url.d.ts","./node_modules/next/dist/compiled/@edge-runtime/cookies/index.d.ts","./node_modules/next/dist/server/web/spec-extension/cookies.d.ts","./node_modules/next/dist/server/web/spec-extension/request.d.ts","./node_modules/next/dist/server/after/builtin-request-context.d.ts","./node_modules/next/dist/server/web/spec-extension/fetch-event.d.ts","./node_modules/next/dist/server/web/spec-extension/response.d.ts","./node_modules/next/dist/build/segment-config/middleware/middleware-config.d.ts","./node_modules/next/dist/server/web/types.d.ts","./node_modules/next/dist/build/webpack/plugins/pages-manifest-plugin.d.ts","./node_modules/next/dist/shared/lib/router/utils/parse-url.d.ts","./node_modules/next/dist/server/base-http/node.d.ts","./node_modules/next/dist/build/webpack/plugins/next-font-manifest-plugin.d.ts","./node_modules/next/dist/server/route-definitions/locale-route-definition.d.ts","./node_modules/next/dist/server/route-definitions/pages-route-definition.d.ts","./node_modules/next/dist/shared/lib/mitt.d.ts","./node_modules/next/dist/client/with-router.d.ts","./node_modules/next/dist/client/router.d.ts","./node_modules/next/dist/client/route-loader.d.ts","./node_modules/next/dist/client/page-loader.d.ts","./node_modules/next/dist/shared/lib/router/router.d.ts","./node_modules/next/dist/shared/lib/router-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/loadable-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/loadable.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/image-config-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/head-manager-context.shared-runtime.d.ts","./node_modules/next/dist/server/route-definitions/app-page-route-definition.d.ts","./node_modules/next/dist/build/webpack/loaders/metadata/types.d.ts","./node_modules/next/dist/build/webpack/loaders/next-app-loader/index.d.ts","./node_modules/next/dist/server/lib/app-dir-module.d.ts","./node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.d.ts","./node_modules/next/dist/server/async-storage/draft-mode-provider.d.ts","./node_modules/next/dist/server/web/spec-extension/adapters/headers.d.ts","./node_modules/next/dist/server/app-render/cache-signal.d.ts","./node_modules/next/dist/server/app-render/dynamic-rendering.d.ts","./node_modules/next/dist/server/request/fallback-params.d.ts","./node_modules/next/dist/server/app-render/work-unit-async-storage-instance.d.ts","./node_modules/next/dist/server/response-cache/index.d.ts","./node_modules/next/dist/server/lib/lazy-result.d.ts","./node_modules/next/dist/server/lib/implicit-tags.d.ts","./node_modules/next/dist/server/app-render/work-unit-async-storage.external.d.ts","./node_modules/next/dist/shared/lib/deep-readonly.d.ts","./node_modules/next/dist/shared/lib/router/utils/parse-relative-url.d.ts","./node_modules/next/dist/server/app-render/app-render.d.ts","./node_modules/next/dist/shared/lib/server-inserted-html.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/amp-context.shared-runtime.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/contexts/entrypoints.d.ts","./node_modules/next/dist/server/route-modules/app-page/module.compiled.d.ts","./node_modules/next/dist/client/components/error-boundary.d.ts","./node_modules/next/dist/client/components/layout-router.d.ts","./node_modules/next/dist/client/components/render-from-template-context.d.ts","./node_modules/next/dist/server/app-render/action-async-storage-instance.d.ts","./node_modules/next/dist/server/app-render/action-async-storage.external.d.ts","./node_modules/next/dist/client/components/client-page.d.ts","./node_modules/next/dist/client/components/client-segment.d.ts","./node_modules/next/dist/server/request/search-params.d.ts","./node_modules/next/dist/client/components/hooks-server-context.d.ts","./node_modules/next/dist/client/components/http-access-fallback/error-boundary.d.ts","./node_modules/next/dist/lib/metadata/types/alternative-urls-types.d.ts","./node_modules/next/dist/lib/metadata/types/extra-types.d.ts","./node_modules/next/dist/lib/metadata/types/metadata-types.d.ts","./node_modules/next/dist/lib/metadata/types/manifest-types.d.ts","./node_modules/next/dist/lib/metadata/types/opengraph-types.d.ts","./node_modules/next/dist/lib/metadata/types/twitter-types.d.ts","./node_modules/next/dist/lib/metadata/types/metadata-interface.d.ts","./node_modules/next/dist/lib/metadata/types/resolvers.d.ts","./node_modules/next/dist/lib/metadata/types/icons.d.ts","./node_modules/next/dist/lib/metadata/resolve-metadata.d.ts","./node_modules/next/dist/lib/metadata/metadata.d.ts","./node_modules/next/dist/lib/framework/boundary-components.d.ts","./node_modules/next/dist/server/app-render/rsc/preloads.d.ts","./node_modules/next/dist/server/app-render/rsc/postpone.d.ts","./node_modules/next/dist/server/app-render/rsc/taint.d.ts","./node_modules/next/dist/shared/lib/segment-cache/segment-value-encoding.d.ts","./node_modules/next/dist/server/app-render/collect-segment-data.d.ts","./node_modules/next/dist/next-devtools/userspace/app/segment-explorer-node.d.ts","./node_modules/next/dist/server/app-render/entry-base.d.ts","./node_modules/next/dist/build/templates/app-page.d.ts","./node_modules/@types/react/jsx-dev-runtime.d.ts","./node_modules/@types/react/compiler-runtime.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/rsc/entrypoints.d.ts","./node_modules/@types/react-dom/client.d.ts","./node_modules/@types/react-dom/static.d.ts","./node_modules/@types/react-dom/server.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/ssr/entrypoints.d.ts","./node_modules/next/dist/server/route-modules/app-page/module.d.ts","./node_modules/next/dist/server/web/adapter.d.ts","./node_modules/next/dist/server/use-cache/cache-life.d.ts","./node_modules/next/dist/server/app-render/types.d.ts","./node_modules/next/dist/client/components/router-reducer/router-reducer-types.d.ts","./node_modules/next/dist/client/flight-data-helpers.d.ts","./node_modules/next/dist/client/components/router-reducer/fetch-server-response.d.ts","./node_modules/next/dist/shared/lib/app-router-context.shared-runtime.d.ts","./node_modules/next/dist/server/route-modules/pages/vendored/contexts/entrypoints.d.ts","./node_modules/next/dist/server/route-modules/pages/module.compiled.d.ts","./node_modules/next/dist/build/templates/pages.d.ts","./node_modules/next/dist/server/route-modules/pages/module.d.ts","./node_modules/next/dist/next-devtools/userspace/pages/pages-dev-overlay-setup.d.ts","./node_modules/next/dist/server/render.d.ts","./node_modules/next/dist/server/route-definitions/pages-api-route-definition.d.ts","./node_modules/next/dist/server/route-matches/pages-api-route-match.d.ts","./node_modules/next/dist/server/route-matchers/route-matcher.d.ts","./node_modules/next/dist/server/route-matcher-providers/route-matcher-provider.d.ts","./node_modules/next/dist/server/route-matcher-managers/route-matcher-manager.d.ts","./node_modules/next/dist/server/normalizers/normalizer.d.ts","./node_modules/next/dist/server/normalizers/locale-route-normalizer.d.ts","./node_modules/next/dist/server/normalizers/request/pathname-normalizer.d.ts","./node_modules/next/dist/server/normalizers/request/suffix.d.ts","./node_modules/next/dist/server/normalizers/request/rsc.d.ts","./node_modules/next/dist/server/normalizers/request/prefetch-rsc.d.ts","./node_modules/next/dist/server/normalizers/request/next-data.d.ts","./node_modules/next/dist/server/normalizers/request/segment-prefix-rsc.d.ts","./node_modules/next/dist/build/static-paths/types.d.ts","./node_modules/next/dist/server/base-server.d.ts","./node_modules/next/dist/server/lib/async-callback-set.d.ts","./node_modules/next/dist/shared/lib/router/utils/route-regex.d.ts","./node_modules/next/dist/shared/lib/router/utils/route-matcher.d.ts","./node_modules/sharp/lib/index.d.ts","./node_modules/next/dist/server/image-optimizer.d.ts","./node_modules/next/dist/server/next-server.d.ts","./node_modules/next/dist/server/lib/types.d.ts","./node_modules/next/dist/server/lib/lru-cache.d.ts","./node_modules/next/dist/server/lib/dev-bundler-service.d.ts","./node_modules/next/dist/server/dev/static-paths-worker.d.ts","./node_modules/next/dist/server/dev/next-dev-server.d.ts","./node_modules/next/dist/server/next.d.ts","./node_modules/next/dist/server/lib/render-server.d.ts","./node_modules/next/dist/server/lib/router-server.d.ts","./node_modules/next/dist/shared/lib/router/utils/path-match.d.ts","./node_modules/next/dist/server/lib/router-utils/filesystem.d.ts","./node_modules/next/dist/server/lib/router-utils/setup-dev-bundler.d.ts","./node_modules/next/dist/server/lib/router-utils/router-server-context.d.ts","./node_modules/next/dist/server/route-modules/route-module.d.ts","./node_modules/next/dist/server/load-components.d.ts","./node_modules/next/dist/server/route-definitions/app-route-route-definition.d.ts","./node_modules/next/dist/server/async-storage/work-store.d.ts","./node_modules/next/dist/server/web/http.d.ts","./node_modules/next/dist/server/route-modules/app-route/shared-modules.d.ts","./node_modules/next/dist/client/components/redirect-status-code.d.ts","./node_modules/next/dist/client/components/redirect-error.d.ts","./node_modules/next/dist/build/templates/app-route.d.ts","./node_modules/next/dist/server/route-modules/app-route/module.d.ts","./node_modules/next/dist/server/route-modules/app-route/module.compiled.d.ts","./node_modules/next/dist/build/segment-config/app/app-segments.d.ts","./node_modules/next/dist/build/utils.d.ts","./node_modules/next/dist/build/turborepo-access-trace/types.d.ts","./node_modules/next/dist/build/turborepo-access-trace/result.d.ts","./node_modules/next/dist/build/turborepo-access-trace/helpers.d.ts","./node_modules/next/dist/build/turborepo-access-trace/index.d.ts","./node_modules/next/dist/export/routes/types.d.ts","./node_modules/next/dist/export/types.d.ts","./node_modules/next/dist/export/worker.d.ts","./node_modules/next/dist/build/worker.d.ts","./node_modules/next/dist/build/index.d.ts","./node_modules/next/dist/server/lib/incremental-cache/index.d.ts","./node_modules/next/dist/server/after/after.d.ts","./node_modules/next/dist/server/after/after-context.d.ts","./node_modules/next/dist/server/app-render/work-async-storage-instance.d.ts","./node_modules/next/dist/server/app-render/work-async-storage.external.d.ts","./node_modules/next/dist/server/request/params.d.ts","./node_modules/next/dist/server/route-matches/route-match.d.ts","./node_modules/next/dist/server/request-meta.d.ts","./node_modules/next/dist/cli/next-test.d.ts","./node_modules/next/dist/server/config-shared.d.ts","./node_modules/next/dist/server/base-http/index.d.ts","./node_modules/next/dist/server/api-utils/index.d.ts","./node_modules/next/dist/types.d.ts","./node_modules/next/dist/shared/lib/html-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/utils.d.ts","./node_modules/next/dist/pages/_app.d.ts","./node_modules/next/app.d.ts","./node_modules/next/dist/server/web/spec-extension/unstable-cache.d.ts","./node_modules/next/dist/server/web/spec-extension/revalidate.d.ts","./node_modules/next/dist/server/web/spec-extension/unstable-no-store.d.ts","./node_modules/next/dist/server/use-cache/cache-tag.d.ts","./node_modules/next/cache.d.ts","./node_modules/next/dist/shared/lib/runtime-config.external.d.ts","./node_modules/next/config.d.ts","./node_modules/next/dist/pages/_document.d.ts","./node_modules/next/document.d.ts","./node_modules/next/dist/shared/lib/dynamic.d.ts","./node_modules/next/dynamic.d.ts","./node_modules/next/dist/pages/_error.d.ts","./node_modules/next/error.d.ts","./node_modules/next/dist/shared/lib/head.d.ts","./node_modules/next/head.d.ts","./node_modules/next/dist/server/request/cookies.d.ts","./node_modules/next/dist/server/request/headers.d.ts","./node_modules/next/dist/server/request/draft-mode.d.ts","./node_modules/next/headers.d.ts","./node_modules/next/dist/shared/lib/get-img-props.d.ts","./node_modules/next/dist/client/image-component.d.ts","./node_modules/next/dist/shared/lib/image-external.d.ts","./node_modules/next/image.d.ts","./node_modules/next/dist/client/link.d.ts","./node_modules/next/link.d.ts","./node_modules/next/dist/client/components/redirect.d.ts","./node_modules/next/dist/client/components/not-found.d.ts","./node_modules/next/dist/client/components/forbidden.d.ts","./node_modules/next/dist/client/components/unauthorized.d.ts","./node_modules/next/dist/client/components/unstable-rethrow.server.d.ts","./node_modules/next/dist/client/components/unstable-rethrow.d.ts","./node_modules/next/dist/client/components/navigation.react-server.d.ts","./node_modules/next/dist/client/components/unrecognized-action-error.d.ts","./node_modules/next/dist/client/components/navigation.d.ts","./node_modules/next/navigation.d.ts","./node_modules/next/router.d.ts","./node_modules/next/dist/client/script.d.ts","./node_modules/next/script.d.ts","./node_modules/next/dist/server/web/spec-extension/user-agent.d.ts","./node_modules/next/dist/compiled/@edge-runtime/primitives/url.d.ts","./node_modules/next/dist/server/web/spec-extension/image-response.d.ts","./node_modules/next/dist/compiled/@vercel/og/satori/index.d.ts","./node_modules/next/dist/compiled/@vercel/og/emoji/index.d.ts","./node_modules/next/dist/compiled/@vercel/og/types.d.ts","./node_modules/next/dist/server/after/index.d.ts","./node_modules/next/dist/server/request/root-params.d.ts","./node_modules/next/dist/server/request/connection.d.ts","./node_modules/next/server.d.ts","./node_modules/next/types/global.d.ts","./node_modules/next/types/compiled.d.ts","./node_modules/next/types.d.ts","./node_modules/next/index.d.ts","./node_modules/next/image-types/global.d.ts","./next-env.d.ts","./node_modules/next-intl/dist/types/plugin/types.d.ts","./node_modules/next-intl/dist/types/plugin/createnextintlplugin.d.ts","./node_modules/next-intl/dist/types/plugin/index.d.ts","./node_modules/next-intl/dist/types/plugin.d.ts","./next.config.ts","./node_modules/playwright-core/types/protocol.d.ts","./node_modules/playwright-core/types/structs.d.ts","./node_modules/playwright-core/types/types.d.ts","./node_modules/playwright-core/index.d.ts","./node_modules/playwright/types/test.d.ts","./node_modules/playwright/test.d.ts","./node_modules/@playwright/test/index.d.ts","./playwright.config.ts","./e2e/item-master-data.spec.ts","./node_modules/next-intl/dist/types/routing/types.d.ts","./node_modules/next-intl/dist/types/routing/config.d.ts","./node_modules/next-intl/dist/types/middleware/middleware.d.ts","./node_modules/next-intl/dist/types/middleware/index.d.ts","./node_modules/next-intl/dist/types/middleware.d.ts","./src/i18n/config.ts","./src/lib/api/auth/auth-config.ts","./src/middleware.ts","./src/app/api/auth/check/route.ts","./src/app/api/auth/login/route.ts","./src/app/api/auth/logout/route.ts","./src/app/api/auth/refresh/route.ts","./src/app/api/auth/signup/route.ts","./src/app/api/proxy/[...path]/route.ts","./src/lib/api/php-proxy.ts","./src/app/api/tenants/[tenantid]/item-master-config/route.ts","./src/app/api/tenants/[tenantid]/item-master-config/pages/[pageid]/route.ts","./node_modules/clsx/clsx.d.mts","./node_modules/tailwind-merge/dist/types.d.ts","./src/lib/utils.ts","./src/components/ui/table.tsx","./src/components/ui/utils.ts","./src/components/ui/card.tsx","./node_modules/@radix-ui/react-context/dist/index.d.mts","./node_modules/@radix-ui/react-checkbox/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-checkbox/dist/index.d.mts","./node_modules/lucide-react/dist/lucide-react.d.ts","./src/components/ui/checkbox.tsx","./node_modules/@radix-ui/react-slot/dist/index.d.mts","./node_modules/class-variance-authority/dist/types.d.ts","./node_modules/class-variance-authority/dist/index.d.ts","./src/components/ui/button.tsx","./node_modules/@radix-ui/react-dismissable-layer/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-dismissable-layer/dist/index.d.mts","./node_modules/@radix-ui/react-focus-scope/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-focus-scope/dist/index.d.mts","./node_modules/@radix-ui/react-arrow/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-arrow/dist/index.d.mts","./node_modules/@radix-ui/react-popper/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/rect/dist/index.d.mts","./node_modules/@radix-ui/react-popper/dist/index.d.mts","./node_modules/@radix-ui/react-portal/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-portal/dist/index.d.mts","./node_modules/@radix-ui/react-select/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-select/dist/index.d.mts","./src/components/ui/select.tsx","./src/components/common/datatable/types.ts","./src/components/common/datatable/pagination.tsx","./node_modules/@radix-ui/react-tabs/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-roving-focus/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-roving-focus/dist/index.d.mts","./node_modules/@radix-ui/react-tabs/dist/index.d.mts","./src/components/ui/tabs.tsx","./src/components/common/datatable/tabfilter.tsx","./src/components/ui/input.tsx","./src/components/common/datatable/searchfilter.tsx","./src/components/common/datatable/datatable.tsx","./src/components/common/datatable/statcards.tsx","./src/components/common/datatable/index.ts","./src/types/item.ts","./src/components/items/dynamicitemform/types.ts","./src/components/ui/textarea.tsx","./node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-label/dist/index.d.mts","./src/components/ui/label.tsx","./src/components/items/dynamicitemform/fields/textfield.tsx","./src/components/items/dynamicitemform/fields/dropdownfield.tsx","./src/components/items/dynamicitemform/fields/numberfield.tsx","./node_modules/date-fns/constants.d.ts","./node_modules/date-fns/locale/types.d.ts","./node_modules/date-fns/fp/types.d.ts","./node_modules/date-fns/types.d.ts","./node_modules/date-fns/add.d.ts","./node_modules/date-fns/addbusinessdays.d.ts","./node_modules/date-fns/adddays.d.ts","./node_modules/date-fns/addhours.d.ts","./node_modules/date-fns/addisoweekyears.d.ts","./node_modules/date-fns/addmilliseconds.d.ts","./node_modules/date-fns/addminutes.d.ts","./node_modules/date-fns/addmonths.d.ts","./node_modules/date-fns/addquarters.d.ts","./node_modules/date-fns/addseconds.d.ts","./node_modules/date-fns/addweeks.d.ts","./node_modules/date-fns/addyears.d.ts","./node_modules/date-fns/areintervalsoverlapping.d.ts","./node_modules/date-fns/clamp.d.ts","./node_modules/date-fns/closestindexto.d.ts","./node_modules/date-fns/closestto.d.ts","./node_modules/date-fns/compareasc.d.ts","./node_modules/date-fns/comparedesc.d.ts","./node_modules/date-fns/constructfrom.d.ts","./node_modules/date-fns/constructnow.d.ts","./node_modules/date-fns/daystoweeks.d.ts","./node_modules/date-fns/differenceinbusinessdays.d.ts","./node_modules/date-fns/differenceincalendardays.d.ts","./node_modules/date-fns/differenceincalendarisoweekyears.d.ts","./node_modules/date-fns/differenceincalendarisoweeks.d.ts","./node_modules/date-fns/differenceincalendarmonths.d.ts","./node_modules/date-fns/differenceincalendarquarters.d.ts","./node_modules/date-fns/differenceincalendarweeks.d.ts","./node_modules/date-fns/differenceincalendaryears.d.ts","./node_modules/date-fns/differenceindays.d.ts","./node_modules/date-fns/differenceinhours.d.ts","./node_modules/date-fns/differenceinisoweekyears.d.ts","./node_modules/date-fns/differenceinmilliseconds.d.ts","./node_modules/date-fns/differenceinminutes.d.ts","./node_modules/date-fns/differenceinmonths.d.ts","./node_modules/date-fns/differenceinquarters.d.ts","./node_modules/date-fns/differenceinseconds.d.ts","./node_modules/date-fns/differenceinweeks.d.ts","./node_modules/date-fns/differenceinyears.d.ts","./node_modules/date-fns/eachdayofinterval.d.ts","./node_modules/date-fns/eachhourofinterval.d.ts","./node_modules/date-fns/eachminuteofinterval.d.ts","./node_modules/date-fns/eachmonthofinterval.d.ts","./node_modules/date-fns/eachquarterofinterval.d.ts","./node_modules/date-fns/eachweekofinterval.d.ts","./node_modules/date-fns/eachweekendofinterval.d.ts","./node_modules/date-fns/eachweekendofmonth.d.ts","./node_modules/date-fns/eachweekendofyear.d.ts","./node_modules/date-fns/eachyearofinterval.d.ts","./node_modules/date-fns/endofday.d.ts","./node_modules/date-fns/endofdecade.d.ts","./node_modules/date-fns/endofhour.d.ts","./node_modules/date-fns/endofisoweek.d.ts","./node_modules/date-fns/endofisoweekyear.d.ts","./node_modules/date-fns/endofminute.d.ts","./node_modules/date-fns/endofmonth.d.ts","./node_modules/date-fns/endofquarter.d.ts","./node_modules/date-fns/endofsecond.d.ts","./node_modules/date-fns/endoftoday.d.ts","./node_modules/date-fns/endoftomorrow.d.ts","./node_modules/date-fns/endofweek.d.ts","./node_modules/date-fns/endofyear.d.ts","./node_modules/date-fns/endofyesterday.d.ts","./node_modules/date-fns/_lib/format/formatters.d.ts","./node_modules/date-fns/_lib/format/longformatters.d.ts","./node_modules/date-fns/format.d.ts","./node_modules/date-fns/formatdistance.d.ts","./node_modules/date-fns/formatdistancestrict.d.ts","./node_modules/date-fns/formatdistancetonow.d.ts","./node_modules/date-fns/formatdistancetonowstrict.d.ts","./node_modules/date-fns/formatduration.d.ts","./node_modules/date-fns/formatiso.d.ts","./node_modules/date-fns/formatiso9075.d.ts","./node_modules/date-fns/formatisoduration.d.ts","./node_modules/date-fns/formatrfc3339.d.ts","./node_modules/date-fns/formatrfc7231.d.ts","./node_modules/date-fns/formatrelative.d.ts","./node_modules/date-fns/fromunixtime.d.ts","./node_modules/date-fns/getdate.d.ts","./node_modules/date-fns/getday.d.ts","./node_modules/date-fns/getdayofyear.d.ts","./node_modules/date-fns/getdaysinmonth.d.ts","./node_modules/date-fns/getdaysinyear.d.ts","./node_modules/date-fns/getdecade.d.ts","./node_modules/date-fns/_lib/defaultoptions.d.ts","./node_modules/date-fns/getdefaultoptions.d.ts","./node_modules/date-fns/gethours.d.ts","./node_modules/date-fns/getisoday.d.ts","./node_modules/date-fns/getisoweek.d.ts","./node_modules/date-fns/getisoweekyear.d.ts","./node_modules/date-fns/getisoweeksinyear.d.ts","./node_modules/date-fns/getmilliseconds.d.ts","./node_modules/date-fns/getminutes.d.ts","./node_modules/date-fns/getmonth.d.ts","./node_modules/date-fns/getoverlappingdaysinintervals.d.ts","./node_modules/date-fns/getquarter.d.ts","./node_modules/date-fns/getseconds.d.ts","./node_modules/date-fns/gettime.d.ts","./node_modules/date-fns/getunixtime.d.ts","./node_modules/date-fns/getweek.d.ts","./node_modules/date-fns/getweekofmonth.d.ts","./node_modules/date-fns/getweekyear.d.ts","./node_modules/date-fns/getweeksinmonth.d.ts","./node_modules/date-fns/getyear.d.ts","./node_modules/date-fns/hourstomilliseconds.d.ts","./node_modules/date-fns/hourstominutes.d.ts","./node_modules/date-fns/hourstoseconds.d.ts","./node_modules/date-fns/interval.d.ts","./node_modules/date-fns/intervaltoduration.d.ts","./node_modules/date-fns/intlformat.d.ts","./node_modules/date-fns/intlformatdistance.d.ts","./node_modules/date-fns/isafter.d.ts","./node_modules/date-fns/isbefore.d.ts","./node_modules/date-fns/isdate.d.ts","./node_modules/date-fns/isequal.d.ts","./node_modules/date-fns/isexists.d.ts","./node_modules/date-fns/isfirstdayofmonth.d.ts","./node_modules/date-fns/isfriday.d.ts","./node_modules/date-fns/isfuture.d.ts","./node_modules/date-fns/islastdayofmonth.d.ts","./node_modules/date-fns/isleapyear.d.ts","./node_modules/date-fns/ismatch.d.ts","./node_modules/date-fns/ismonday.d.ts","./node_modules/date-fns/ispast.d.ts","./node_modules/date-fns/issameday.d.ts","./node_modules/date-fns/issamehour.d.ts","./node_modules/date-fns/issameisoweek.d.ts","./node_modules/date-fns/issameisoweekyear.d.ts","./node_modules/date-fns/issameminute.d.ts","./node_modules/date-fns/issamemonth.d.ts","./node_modules/date-fns/issamequarter.d.ts","./node_modules/date-fns/issamesecond.d.ts","./node_modules/date-fns/issameweek.d.ts","./node_modules/date-fns/issameyear.d.ts","./node_modules/date-fns/issaturday.d.ts","./node_modules/date-fns/issunday.d.ts","./node_modules/date-fns/isthishour.d.ts","./node_modules/date-fns/isthisisoweek.d.ts","./node_modules/date-fns/isthisminute.d.ts","./node_modules/date-fns/isthismonth.d.ts","./node_modules/date-fns/isthisquarter.d.ts","./node_modules/date-fns/isthissecond.d.ts","./node_modules/date-fns/isthisweek.d.ts","./node_modules/date-fns/isthisyear.d.ts","./node_modules/date-fns/isthursday.d.ts","./node_modules/date-fns/istoday.d.ts","./node_modules/date-fns/istomorrow.d.ts","./node_modules/date-fns/istuesday.d.ts","./node_modules/date-fns/isvalid.d.ts","./node_modules/date-fns/iswednesday.d.ts","./node_modules/date-fns/isweekend.d.ts","./node_modules/date-fns/iswithininterval.d.ts","./node_modules/date-fns/isyesterday.d.ts","./node_modules/date-fns/lastdayofdecade.d.ts","./node_modules/date-fns/lastdayofisoweek.d.ts","./node_modules/date-fns/lastdayofisoweekyear.d.ts","./node_modules/date-fns/lastdayofmonth.d.ts","./node_modules/date-fns/lastdayofquarter.d.ts","./node_modules/date-fns/lastdayofweek.d.ts","./node_modules/date-fns/lastdayofyear.d.ts","./node_modules/date-fns/_lib/format/lightformatters.d.ts","./node_modules/date-fns/lightformat.d.ts","./node_modules/date-fns/max.d.ts","./node_modules/date-fns/milliseconds.d.ts","./node_modules/date-fns/millisecondstohours.d.ts","./node_modules/date-fns/millisecondstominutes.d.ts","./node_modules/date-fns/millisecondstoseconds.d.ts","./node_modules/date-fns/min.d.ts","./node_modules/date-fns/minutestohours.d.ts","./node_modules/date-fns/minutestomilliseconds.d.ts","./node_modules/date-fns/minutestoseconds.d.ts","./node_modules/date-fns/monthstoquarters.d.ts","./node_modules/date-fns/monthstoyears.d.ts","./node_modules/date-fns/nextday.d.ts","./node_modules/date-fns/nextfriday.d.ts","./node_modules/date-fns/nextmonday.d.ts","./node_modules/date-fns/nextsaturday.d.ts","./node_modules/date-fns/nextsunday.d.ts","./node_modules/date-fns/nextthursday.d.ts","./node_modules/date-fns/nexttuesday.d.ts","./node_modules/date-fns/nextwednesday.d.ts","./node_modules/date-fns/parse/_lib/types.d.ts","./node_modules/date-fns/parse/_lib/setter.d.ts","./node_modules/date-fns/parse/_lib/parser.d.ts","./node_modules/date-fns/parse/_lib/parsers.d.ts","./node_modules/date-fns/parse.d.ts","./node_modules/date-fns/parseiso.d.ts","./node_modules/date-fns/parsejson.d.ts","./node_modules/date-fns/previousday.d.ts","./node_modules/date-fns/previousfriday.d.ts","./node_modules/date-fns/previousmonday.d.ts","./node_modules/date-fns/previoussaturday.d.ts","./node_modules/date-fns/previoussunday.d.ts","./node_modules/date-fns/previousthursday.d.ts","./node_modules/date-fns/previoustuesday.d.ts","./node_modules/date-fns/previouswednesday.d.ts","./node_modules/date-fns/quarterstomonths.d.ts","./node_modules/date-fns/quarterstoyears.d.ts","./node_modules/date-fns/roundtonearesthours.d.ts","./node_modules/date-fns/roundtonearestminutes.d.ts","./node_modules/date-fns/secondstohours.d.ts","./node_modules/date-fns/secondstomilliseconds.d.ts","./node_modules/date-fns/secondstominutes.d.ts","./node_modules/date-fns/set.d.ts","./node_modules/date-fns/setdate.d.ts","./node_modules/date-fns/setday.d.ts","./node_modules/date-fns/setdayofyear.d.ts","./node_modules/date-fns/setdefaultoptions.d.ts","./node_modules/date-fns/sethours.d.ts","./node_modules/date-fns/setisoday.d.ts","./node_modules/date-fns/setisoweek.d.ts","./node_modules/date-fns/setisoweekyear.d.ts","./node_modules/date-fns/setmilliseconds.d.ts","./node_modules/date-fns/setminutes.d.ts","./node_modules/date-fns/setmonth.d.ts","./node_modules/date-fns/setquarter.d.ts","./node_modules/date-fns/setseconds.d.ts","./node_modules/date-fns/setweek.d.ts","./node_modules/date-fns/setweekyear.d.ts","./node_modules/date-fns/setyear.d.ts","./node_modules/date-fns/startofday.d.ts","./node_modules/date-fns/startofdecade.d.ts","./node_modules/date-fns/startofhour.d.ts","./node_modules/date-fns/startofisoweek.d.ts","./node_modules/date-fns/startofisoweekyear.d.ts","./node_modules/date-fns/startofminute.d.ts","./node_modules/date-fns/startofmonth.d.ts","./node_modules/date-fns/startofquarter.d.ts","./node_modules/date-fns/startofsecond.d.ts","./node_modules/date-fns/startoftoday.d.ts","./node_modules/date-fns/startoftomorrow.d.ts","./node_modules/date-fns/startofweek.d.ts","./node_modules/date-fns/startofweekyear.d.ts","./node_modules/date-fns/startofyear.d.ts","./node_modules/date-fns/startofyesterday.d.ts","./node_modules/date-fns/sub.d.ts","./node_modules/date-fns/subbusinessdays.d.ts","./node_modules/date-fns/subdays.d.ts","./node_modules/date-fns/subhours.d.ts","./node_modules/date-fns/subisoweekyears.d.ts","./node_modules/date-fns/submilliseconds.d.ts","./node_modules/date-fns/subminutes.d.ts","./node_modules/date-fns/submonths.d.ts","./node_modules/date-fns/subquarters.d.ts","./node_modules/date-fns/subseconds.d.ts","./node_modules/date-fns/subweeks.d.ts","./node_modules/date-fns/subyears.d.ts","./node_modules/date-fns/todate.d.ts","./node_modules/date-fns/transpose.d.ts","./node_modules/date-fns/weekstodays.d.ts","./node_modules/date-fns/yearstodays.d.ts","./node_modules/date-fns/yearstomonths.d.ts","./node_modules/date-fns/yearstoquarters.d.ts","./node_modules/date-fns/index.d.ts","./node_modules/date-fns/locale/af.d.ts","./node_modules/date-fns/locale/ar.d.ts","./node_modules/date-fns/locale/ar-dz.d.ts","./node_modules/date-fns/locale/ar-eg.d.ts","./node_modules/date-fns/locale/ar-ma.d.ts","./node_modules/date-fns/locale/ar-sa.d.ts","./node_modules/date-fns/locale/ar-tn.d.ts","./node_modules/date-fns/locale/az.d.ts","./node_modules/date-fns/locale/be.d.ts","./node_modules/date-fns/locale/be-tarask.d.ts","./node_modules/date-fns/locale/bg.d.ts","./node_modules/date-fns/locale/bn.d.ts","./node_modules/date-fns/locale/bs.d.ts","./node_modules/date-fns/locale/ca.d.ts","./node_modules/date-fns/locale/ckb.d.ts","./node_modules/date-fns/locale/cs.d.ts","./node_modules/date-fns/locale/cy.d.ts","./node_modules/date-fns/locale/da.d.ts","./node_modules/date-fns/locale/de.d.ts","./node_modules/date-fns/locale/de-at.d.ts","./node_modules/date-fns/locale/el.d.ts","./node_modules/date-fns/locale/en-au.d.ts","./node_modules/date-fns/locale/en-ca.d.ts","./node_modules/date-fns/locale/en-gb.d.ts","./node_modules/date-fns/locale/en-ie.d.ts","./node_modules/date-fns/locale/en-in.d.ts","./node_modules/date-fns/locale/en-nz.d.ts","./node_modules/date-fns/locale/en-us.d.ts","./node_modules/date-fns/locale/en-za.d.ts","./node_modules/date-fns/locale/eo.d.ts","./node_modules/date-fns/locale/es.d.ts","./node_modules/date-fns/locale/et.d.ts","./node_modules/date-fns/locale/eu.d.ts","./node_modules/date-fns/locale/fa-ir.d.ts","./node_modules/date-fns/locale/fi.d.ts","./node_modules/date-fns/locale/fr.d.ts","./node_modules/date-fns/locale/fr-ca.d.ts","./node_modules/date-fns/locale/fr-ch.d.ts","./node_modules/date-fns/locale/fy.d.ts","./node_modules/date-fns/locale/gd.d.ts","./node_modules/date-fns/locale/gl.d.ts","./node_modules/date-fns/locale/gu.d.ts","./node_modules/date-fns/locale/he.d.ts","./node_modules/date-fns/locale/hi.d.ts","./node_modules/date-fns/locale/hr.d.ts","./node_modules/date-fns/locale/ht.d.ts","./node_modules/date-fns/locale/hu.d.ts","./node_modules/date-fns/locale/hy.d.ts","./node_modules/date-fns/locale/id.d.ts","./node_modules/date-fns/locale/is.d.ts","./node_modules/date-fns/locale/it.d.ts","./node_modules/date-fns/locale/it-ch.d.ts","./node_modules/date-fns/locale/ja.d.ts","./node_modules/date-fns/locale/ja-hira.d.ts","./node_modules/date-fns/locale/ka.d.ts","./node_modules/date-fns/locale/kk.d.ts","./node_modules/date-fns/locale/km.d.ts","./node_modules/date-fns/locale/kn.d.ts","./node_modules/date-fns/locale/ko.d.ts","./node_modules/date-fns/locale/lb.d.ts","./node_modules/date-fns/locale/lt.d.ts","./node_modules/date-fns/locale/lv.d.ts","./node_modules/date-fns/locale/mk.d.ts","./node_modules/date-fns/locale/mn.d.ts","./node_modules/date-fns/locale/ms.d.ts","./node_modules/date-fns/locale/mt.d.ts","./node_modules/date-fns/locale/nb.d.ts","./node_modules/date-fns/locale/nl.d.ts","./node_modules/date-fns/locale/nl-be.d.ts","./node_modules/date-fns/locale/nn.d.ts","./node_modules/date-fns/locale/oc.d.ts","./node_modules/date-fns/locale/pl.d.ts","./node_modules/date-fns/locale/pt.d.ts","./node_modules/date-fns/locale/pt-br.d.ts","./node_modules/date-fns/locale/ro.d.ts","./node_modules/date-fns/locale/ru.d.ts","./node_modules/date-fns/locale/se.d.ts","./node_modules/date-fns/locale/sk.d.ts","./node_modules/date-fns/locale/sl.d.ts","./node_modules/date-fns/locale/sq.d.ts","./node_modules/date-fns/locale/sr.d.ts","./node_modules/date-fns/locale/sr-latn.d.ts","./node_modules/date-fns/locale/sv.d.ts","./node_modules/date-fns/locale/ta.d.ts","./node_modules/date-fns/locale/te.d.ts","./node_modules/date-fns/locale/th.d.ts","./node_modules/date-fns/locale/tr.d.ts","./node_modules/date-fns/locale/ug.d.ts","./node_modules/date-fns/locale/uk.d.ts","./node_modules/date-fns/locale/uz.d.ts","./node_modules/date-fns/locale/uz-cyrl.d.ts","./node_modules/date-fns/locale/vi.d.ts","./node_modules/date-fns/locale/zh-cn.d.ts","./node_modules/date-fns/locale/zh-hk.d.ts","./node_modules/date-fns/locale/zh-tw.d.ts","./node_modules/date-fns/locale.d.ts","./node_modules/@date-fns/tz/constants/index.d.ts","./node_modules/@date-fns/tz/date/index.d.ts","./node_modules/@date-fns/tz/date/mini.d.ts","./node_modules/@date-fns/tz/tz/index.d.ts","./node_modules/@date-fns/tz/tzoffset/index.d.ts","./node_modules/@date-fns/tz/tzscan/index.d.ts","./node_modules/@date-fns/tz/tzname/index.d.ts","./node_modules/@date-fns/tz/index.d.ts","./node_modules/react-day-picker/dist/esm/components/button.d.ts","./node_modules/react-day-picker/dist/esm/components/captionlabel.d.ts","./node_modules/react-day-picker/dist/esm/components/chevron.d.ts","./node_modules/react-day-picker/dist/esm/components/monthcaption.d.ts","./node_modules/react-day-picker/dist/esm/components/week.d.ts","./node_modules/react-day-picker/dist/esm/labels/labeldaybutton.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelgrid.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelgridcell.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelmonthdropdown.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelnav.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelnext.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelprevious.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelweekday.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelweeknumber.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelweeknumberheader.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelyeardropdown.d.ts","./node_modules/react-day-picker/dist/esm/labels/index.d.ts","./node_modules/react-day-picker/dist/esm/ui.d.ts","./node_modules/react-day-picker/dist/esm/classes/calendarweek.d.ts","./node_modules/react-day-picker/dist/esm/classes/calendarmonth.d.ts","./node_modules/react-day-picker/dist/esm/types/props.d.ts","./node_modules/react-day-picker/dist/esm/types/selection.d.ts","./node_modules/react-day-picker/dist/esm/usedaypicker.d.ts","./node_modules/react-day-picker/dist/esm/types/deprecated.d.ts","./node_modules/react-day-picker/dist/esm/types/index.d.ts","./node_modules/react-day-picker/dist/esm/components/day.d.ts","./node_modules/react-day-picker/dist/esm/components/daybutton.d.ts","./node_modules/react-day-picker/dist/esm/components/dropdown.d.ts","./node_modules/react-day-picker/dist/esm/components/dropdownnav.d.ts","./node_modules/react-day-picker/dist/esm/components/footer.d.ts","./node_modules/react-day-picker/dist/esm/components/month.d.ts","./node_modules/react-day-picker/dist/esm/components/monthgrid.d.ts","./node_modules/react-day-picker/dist/esm/components/months.d.ts","./node_modules/react-day-picker/dist/esm/components/monthsdropdown.d.ts","./node_modules/react-day-picker/dist/esm/components/nav.d.ts","./node_modules/react-day-picker/dist/esm/components/nextmonthbutton.d.ts","./node_modules/react-day-picker/dist/esm/components/option.d.ts","./node_modules/react-day-picker/dist/esm/components/previousmonthbutton.d.ts","./node_modules/react-day-picker/dist/esm/components/root.d.ts","./node_modules/react-day-picker/dist/esm/components/select.d.ts","./node_modules/react-day-picker/dist/esm/components/weekday.d.ts","./node_modules/react-day-picker/dist/esm/components/weekdays.d.ts","./node_modules/react-day-picker/dist/esm/components/weeknumber.d.ts","./node_modules/react-day-picker/dist/esm/components/weeknumberheader.d.ts","./node_modules/react-day-picker/dist/esm/components/weeks.d.ts","./node_modules/react-day-picker/dist/esm/components/yearsdropdown.d.ts","./node_modules/react-day-picker/dist/esm/components/custom-components.d.ts","./node_modules/react-day-picker/dist/esm/formatters/formatcaption.d.ts","./node_modules/react-day-picker/dist/esm/formatters/formatday.d.ts","./node_modules/react-day-picker/dist/esm/formatters/formatmonthdropdown.d.ts","./node_modules/react-day-picker/dist/esm/formatters/formatweekdayname.d.ts","./node_modules/react-day-picker/dist/esm/formatters/formatweeknumber.d.ts","./node_modules/react-day-picker/dist/esm/formatters/formatweeknumberheader.d.ts","./node_modules/react-day-picker/dist/esm/formatters/formatyeardropdown.d.ts","./node_modules/react-day-picker/dist/esm/formatters/index.d.ts","./node_modules/react-day-picker/dist/esm/types/shared.d.ts","./node_modules/react-day-picker/dist/esm/classes/datelib.d.ts","./node_modules/react-day-picker/dist/esm/classes/calendarday.d.ts","./node_modules/react-day-picker/dist/esm/classes/index.d.ts","./node_modules/react-day-picker/dist/esm/daypicker.d.ts","./node_modules/react-day-picker/dist/esm/helpers/getdefaultclassnames.d.ts","./node_modules/react-day-picker/dist/esm/helpers/index.d.ts","./node_modules/react-day-picker/dist/esm/utils/addtorange.d.ts","./node_modules/react-day-picker/dist/esm/utils/datematchmodifiers.d.ts","./node_modules/react-day-picker/dist/esm/utils/rangecontainsdayofweek.d.ts","./node_modules/react-day-picker/dist/esm/utils/rangecontainsmodifiers.d.ts","./node_modules/react-day-picker/dist/esm/utils/rangeincludesdate.d.ts","./node_modules/react-day-picker/dist/esm/utils/rangeoverlaps.d.ts","./node_modules/react-day-picker/dist/esm/utils/typeguards.d.ts","./node_modules/react-day-picker/dist/esm/utils/index.d.ts","./node_modules/react-day-picker/dist/esm/index.d.ts","./src/components/ui/calendar.tsx","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-context/dist/index.d.mts","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-dismissable-layer/dist/index.d.mts","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-focus-scope/dist/index.d.mts","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-arrow/dist/index.d.mts","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/rect/dist/index.d.mts","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-popper/dist/index.d.mts","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-portal/dist/index.d.mts","./node_modules/@radix-ui/react-popover/dist/index.d.mts","./src/components/ui/popover.tsx","./src/components/items/dynamicitemform/fields/datefield.tsx","./node_modules/@radix-ui/react-switch/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-switch/dist/index.d.mts","./src/components/ui/switch.tsx","./src/components/items/dynamicitemform/fields/checkboxfield.tsx","./src/components/items/dynamicitemform/fields/filefield.tsx","./src/components/items/dynamicitemform/fields/customfield.tsx","./src/components/items/dynamicitemform/fields/index.ts","./src/components/items/dynamicitemform/hooks/useformstructure.ts","./src/components/items/dynamicitemform/hooks/useconditionalfields.ts","./src/components/items/dynamicitemform/hooks/usedynamicformstate.ts","./src/components/items/dynamicitemform/hooks/index.ts","./src/components/items/itemform/constants.ts","./node_modules/zod/v4/core/standard-schema.d.cts","./node_modules/zod/v4/core/util.d.cts","./node_modules/zod/v4/core/versions.d.cts","./node_modules/zod/v4/core/schemas.d.cts","./node_modules/zod/v4/core/checks.d.cts","./node_modules/zod/v4/core/errors.d.cts","./node_modules/zod/v4/core/core.d.cts","./node_modules/zod/v4/core/parse.d.cts","./node_modules/zod/v4/core/regexes.d.cts","./node_modules/zod/v4/locales/ar.d.cts","./node_modules/zod/v4/locales/az.d.cts","./node_modules/zod/v4/locales/be.d.cts","./node_modules/zod/v4/locales/bg.d.cts","./node_modules/zod/v4/locales/ca.d.cts","./node_modules/zod/v4/locales/cs.d.cts","./node_modules/zod/v4/locales/da.d.cts","./node_modules/zod/v4/locales/de.d.cts","./node_modules/zod/v4/locales/en.d.cts","./node_modules/zod/v4/locales/eo.d.cts","./node_modules/zod/v4/locales/es.d.cts","./node_modules/zod/v4/locales/fa.d.cts","./node_modules/zod/v4/locales/fi.d.cts","./node_modules/zod/v4/locales/fr.d.cts","./node_modules/zod/v4/locales/fr-ca.d.cts","./node_modules/zod/v4/locales/he.d.cts","./node_modules/zod/v4/locales/hu.d.cts","./node_modules/zod/v4/locales/id.d.cts","./node_modules/zod/v4/locales/is.d.cts","./node_modules/zod/v4/locales/it.d.cts","./node_modules/zod/v4/locales/ja.d.cts","./node_modules/zod/v4/locales/ka.d.cts","./node_modules/zod/v4/locales/kh.d.cts","./node_modules/zod/v4/locales/km.d.cts","./node_modules/zod/v4/locales/ko.d.cts","./node_modules/zod/v4/locales/lt.d.cts","./node_modules/zod/v4/locales/mk.d.cts","./node_modules/zod/v4/locales/ms.d.cts","./node_modules/zod/v4/locales/nl.d.cts","./node_modules/zod/v4/locales/no.d.cts","./node_modules/zod/v4/locales/ota.d.cts","./node_modules/zod/v4/locales/ps.d.cts","./node_modules/zod/v4/locales/pl.d.cts","./node_modules/zod/v4/locales/pt.d.cts","./node_modules/zod/v4/locales/ru.d.cts","./node_modules/zod/v4/locales/sl.d.cts","./node_modules/zod/v4/locales/sv.d.cts","./node_modules/zod/v4/locales/ta.d.cts","./node_modules/zod/v4/locales/th.d.cts","./node_modules/zod/v4/locales/tr.d.cts","./node_modules/zod/v4/locales/ua.d.cts","./node_modules/zod/v4/locales/uk.d.cts","./node_modules/zod/v4/locales/ur.d.cts","./node_modules/zod/v4/locales/vi.d.cts","./node_modules/zod/v4/locales/zh-cn.d.cts","./node_modules/zod/v4/locales/zh-tw.d.cts","./node_modules/zod/v4/locales/yo.d.cts","./node_modules/zod/v4/locales/index.d.cts","./node_modules/zod/v4/core/registries.d.cts","./node_modules/zod/v4/core/doc.d.cts","./node_modules/zod/v4/core/api.d.cts","./node_modules/zod/v4/core/json-schema.d.cts","./node_modules/zod/v4/core/to-json-schema.d.cts","./node_modules/zod/v4/core/index.d.cts","./node_modules/zod/v4/classic/errors.d.cts","./node_modules/zod/v4/classic/parse.d.cts","./node_modules/zod/v4/classic/schemas.d.cts","./node_modules/zod/v4/classic/checks.d.cts","./node_modules/zod/v4/classic/compat.d.cts","./node_modules/zod/v4/classic/iso.d.cts","./node_modules/zod/v4/classic/coerce.d.cts","./node_modules/zod/v4/classic/external.d.cts","./node_modules/zod/index.d.cts","./src/lib/utils/validation.ts","./src/components/items/itemform/types.ts","./node_modules/react-hook-form/dist/constants.d.ts","./node_modules/react-hook-form/dist/utils/createsubject.d.ts","./node_modules/react-hook-form/dist/types/events.d.ts","./node_modules/react-hook-form/dist/types/path/common.d.ts","./node_modules/react-hook-form/dist/types/path/eager.d.ts","./node_modules/react-hook-form/dist/types/path/index.d.ts","./node_modules/react-hook-form/dist/types/fieldarray.d.ts","./node_modules/react-hook-form/dist/types/resolvers.d.ts","./node_modules/react-hook-form/dist/types/form.d.ts","./node_modules/react-hook-form/dist/types/utils.d.ts","./node_modules/react-hook-form/dist/types/fields.d.ts","./node_modules/react-hook-form/dist/types/errors.d.ts","./node_modules/react-hook-form/dist/types/validator.d.ts","./node_modules/react-hook-form/dist/types/controller.d.ts","./node_modules/react-hook-form/dist/types/index.d.ts","./node_modules/react-hook-form/dist/controller.d.ts","./node_modules/react-hook-form/dist/form.d.ts","./node_modules/react-hook-form/dist/logic/appenderrors.d.ts","./node_modules/react-hook-form/dist/logic/createformcontrol.d.ts","./node_modules/react-hook-form/dist/logic/index.d.ts","./node_modules/react-hook-form/dist/usecontroller.d.ts","./node_modules/react-hook-form/dist/usefieldarray.d.ts","./node_modules/react-hook-form/dist/useform.d.ts","./node_modules/react-hook-form/dist/useformcontext.d.ts","./node_modules/react-hook-form/dist/useformstate.d.ts","./node_modules/react-hook-form/dist/usewatch.d.ts","./node_modules/react-hook-form/dist/utils/get.d.ts","./node_modules/react-hook-form/dist/utils/set.d.ts","./node_modules/react-hook-form/dist/utils/index.d.ts","./node_modules/react-hook-form/dist/watch.d.ts","./node_modules/react-hook-form/dist/index.d.ts","./src/components/items/itemform/hooks/useitemformstate.ts","./src/components/items/itemform/hooks/usebommanagement.ts","./src/components/items/itemform/hooks/usebendingdetails.ts","./src/components/items/itemform/context/itemformcontext.tsx","./src/components/items/itemform/context/index.ts","./src/components/items/itemform/forms/materialform.tsx","./src/components/items/itemform/forms/productform.tsx","./src/components/items/itemform/forms/parts/assemblypartform.tsx","./src/components/items/itemform/forms/parts/bendingpartform.tsx","./src/components/items/itemform/forms/parts/purchasedpartform.tsx","./src/components/items/itemform/forms/parts/index.ts","./src/components/items/itemform/forms/partform.tsx","./src/components/items/itemform/forms/index.ts","./src/components/items/itemform/hooks/index.ts","./src/components/items/itemmasterdatamanagement/types.ts","./src/contexts/authcontext.tsx","./src/lib/cache/tenantawarecache.ts","./src/lib/cache/index.ts","./src/types/item-master-api.ts","./src/lib/api/auth-headers.ts","./src/lib/api/error-handler.ts","./src/lib/api/logger.ts","./src/lib/api/item-master.ts","./src/lib/api/transformers.ts","./src/contexts/itemmastercontext.tsx","./src/components/items/itemmasterdatamanagement/components/draggablesection.tsx","./src/components/ui/badge.tsx","./src/components/items/itemmasterdatamanagement/components/draggablefield.tsx","./src/components/items/itemmasterdatamanagement/components/index.ts","./node_modules/sonner/dist/index.d.mts","./src/components/items/itemmasterdatamanagement/utils/pathutils.ts","./src/components/items/itemmasterdatamanagement/hooks/usepagemanagement.ts","./src/components/items/itemmasterdatamanagement/hooks/usesectionmanagement.ts","./src/components/items/itemmasterdatamanagement/components/conditionaldisplayui.tsx","./src/components/items/itemmasterdatamanagement/hooks/usefieldmanagement.ts","./src/components/items/itemmasterdatamanagement/hooks/usemasterfieldmanagement.ts","./src/components/items/itemmasterdatamanagement/hooks/usetemplatemanagement.ts","./src/components/items/itemmasterdatamanagement/hooks/useattributemanagement.ts","./src/components/items/itemmasterdatamanagement/hooks/usetabmanagement.ts","./src/components/items/itemmasterdatamanagement/hooks/index.ts","./src/components/items/itemmasterdatamanagement/tabs/categorytab/index.tsx","./src/components/items/itemmasterdatamanagement/tabs/masterfieldtab/index.tsx","./node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-dialog/dist/index.d.mts","./node_modules/@radix-ui/react-visually-hidden/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-visually-hidden/dist/index.d.mts","./src/components/ui/visually-hidden.tsx","./src/components/ui/dialog.tsx","./src/components/items/bommanagementsection.tsx","./src/components/items/itemmasterdatamanagement/tabs/hierarchytab/index.tsx","./src/components/items/itemmasterdatamanagement/tabs/sectionstab.tsx","./src/components/items/itemmasterdatamanagement/tabs/index.ts","./src/hooks/useauthguard.ts","./src/hooks/usecurrenttime.ts","./src/hooks/useuserrole.ts","./node_modules/use-intl/dist/types/core/abstractintlmessages.d.ts","./node_modules/use-intl/dist/types/core/translationvalues.d.ts","./node_modules/use-intl/dist/types/core/timezone.d.ts","./node_modules/use-intl/dist/types/core/datetimeformatoptions.d.ts","./node_modules/@formatjs/ecma402-abstract/canonicalizelocalelist.d.ts","./node_modules/@formatjs/ecma402-abstract/canonicalizetimezonename.d.ts","./node_modules/@formatjs/ecma402-abstract/coerceoptionstoobject.d.ts","./node_modules/@formatjs/ecma402-abstract/getnumberoption.d.ts","./node_modules/@formatjs/ecma402-abstract/getoption.d.ts","./node_modules/@formatjs/ecma402-abstract/getoptionsobject.d.ts","./node_modules/@formatjs/ecma402-abstract/getstringorbooleanoption.d.ts","./node_modules/@formatjs/ecma402-abstract/issanctionedsimpleunitidentifier.d.ts","./node_modules/@formatjs/ecma402-abstract/isvalidtimezonename.d.ts","./node_modules/@formatjs/ecma402-abstract/iswellformedcurrencycode.d.ts","./node_modules/@formatjs/ecma402-abstract/iswellformedunitidentifier.d.ts","./node_modules/decimal.js/decimal.d.ts","./node_modules/@formatjs/ecma402-abstract/types/core.d.ts","./node_modules/@formatjs/ecma402-abstract/types/plural-rules.d.ts","./node_modules/@formatjs/ecma402-abstract/types/number.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/applyunsignedroundingmode.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/collapsenumberrange.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/computeexponent.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/computeexponentformagnitude.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/currencydigits.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/format_to_parts.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/formatapproximately.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/formatnumeric.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/formatnumericrange.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/formatnumericrangetoparts.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/formatnumerictoparts.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/formatnumerictostring.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/getunsignedroundingmode.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/initializenumberformat.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/partitionnumberpattern.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/partitionnumberrangepattern.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/setnumberformatdigitoptions.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/setnumberformatunitoptions.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/torawfixed.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/torawprecision.d.ts","./node_modules/@formatjs/ecma402-abstract/partitionpattern.d.ts","./node_modules/@formatjs/ecma402-abstract/supportedlocales.d.ts","./node_modules/@formatjs/ecma402-abstract/utils.d.ts","./node_modules/@formatjs/ecma402-abstract/262.d.ts","./node_modules/@formatjs/ecma402-abstract/data.d.ts","./node_modules/@formatjs/ecma402-abstract/types/date-time.d.ts","./node_modules/@formatjs/ecma402-abstract/types/displaynames.d.ts","./node_modules/@formatjs/ecma402-abstract/types/list.d.ts","./node_modules/@formatjs/ecma402-abstract/types/relative-time.d.ts","./node_modules/@formatjs/ecma402-abstract/constants.d.ts","./node_modules/@formatjs/ecma402-abstract/tointlmathematicalvalue.d.ts","./node_modules/@formatjs/ecma402-abstract/index.d.ts","./node_modules/@formatjs/icu-skeleton-parser/date-time.d.ts","./node_modules/@formatjs/icu-skeleton-parser/number.d.ts","./node_modules/@formatjs/icu-skeleton-parser/index.d.ts","./node_modules/@formatjs/icu-messageformat-parser/types.d.ts","./node_modules/@formatjs/icu-messageformat-parser/error.d.ts","./node_modules/@formatjs/icu-messageformat-parser/parser.d.ts","./node_modules/@formatjs/icu-messageformat-parser/manipulator.d.ts","./node_modules/@formatjs/icu-messageformat-parser/index.d.ts","./node_modules/intl-messageformat/src/formatters.d.ts","./node_modules/intl-messageformat/src/core.d.ts","./node_modules/intl-messageformat/src/error.d.ts","./node_modules/intl-messageformat/index.d.ts","./node_modules/use-intl/dist/types/core/numberformatoptions.d.ts","./node_modules/use-intl/dist/types/core/formats.d.ts","./node_modules/use-intl/dist/types/core/appconfig.d.ts","./node_modules/use-intl/dist/types/core/intlerrorcode.d.ts","./node_modules/use-intl/dist/types/core/intlerror.d.ts","./node_modules/use-intl/dist/types/core/types.d.ts","./node_modules/use-intl/dist/types/core/intlconfig.d.ts","./node_modules/@schummar/icu-type-parser/dist/index.d.ts","./node_modules/use-intl/dist/types/core/icuargs.d.ts","./node_modules/use-intl/dist/types/core/icutags.d.ts","./node_modules/use-intl/dist/types/core/messagekeys.d.ts","./node_modules/use-intl/dist/types/core/formatters.d.ts","./node_modules/use-intl/dist/types/core/createtranslator.d.ts","./node_modules/use-intl/dist/types/core/relativetimeformatoptions.d.ts","./node_modules/use-intl/dist/types/core/createformatter.d.ts","./node_modules/use-intl/dist/types/core/initializeconfig.d.ts","./node_modules/use-intl/dist/types/core/haslocale.d.ts","./node_modules/use-intl/dist/types/core/index.d.ts","./node_modules/use-intl/dist/types/core.d.ts","./node_modules/next-intl/dist/types/server/react-server/getrequestconfig.d.ts","./node_modules/next-intl/dist/types/server/react-server/getformatter.d.ts","./node_modules/use-intl/dist/types/react/intlprovider.d.ts","./node_modules/use-intl/dist/types/react/usetranslations.d.ts","./node_modules/use-intl/dist/types/react/uselocale.d.ts","./node_modules/use-intl/dist/types/react/usenow.d.ts","./node_modules/use-intl/dist/types/react/usetimezone.d.ts","./node_modules/use-intl/dist/types/react/usemessages.d.ts","./node_modules/use-intl/dist/types/react/useformatter.d.ts","./node_modules/use-intl/dist/types/react/index.d.ts","./node_modules/use-intl/dist/types/react.d.ts","./node_modules/use-intl/dist/types/index.d.ts","./node_modules/next-intl/dist/types/server/react-server/getnow.d.ts","./node_modules/next-intl/dist/types/server/react-server/gettimezone.d.ts","./node_modules/next-intl/dist/types/server/react-server/gettranslations.d.ts","./node_modules/next-intl/dist/types/server/react-server/getconfig.d.ts","./node_modules/next-intl/dist/types/server/react-server/getmessages.d.ts","./node_modules/next-intl/dist/types/server/react-server/getlocale.d.ts","./node_modules/next-intl/dist/types/server/react-server/requestlocalecache.d.ts","./node_modules/next-intl/dist/types/server/react-server/index.d.ts","./node_modules/next-intl/dist/types/server.react-server.d.ts","./src/i18n/request.ts","./src/lib/api/auth/types.ts","./src/lib/api/client.ts","./src/lib/api/items.ts","./src/types/master-data.ts","./src/lib/api/master-data.ts","./src/lib/auth/token-refresh.ts","./node_modules/zustand/esm/vanilla.d.mts","./node_modules/zustand/esm/react.d.mts","./node_modules/zustand/esm/index.d.mts","./node_modules/zustand/esm/middleware/redux.d.mts","./node_modules/zustand/esm/middleware/devtools.d.mts","./node_modules/zustand/esm/middleware/subscribewithselector.d.mts","./node_modules/zustand/esm/middleware/combine.d.mts","./node_modules/zustand/esm/middleware/persist.d.mts","./node_modules/zustand/esm/middleware.d.mts","./src/store/menustore.ts","./src/lib/utils/menutransform.ts","./src/lib/validations/auth.ts","./src/store/demostore.ts","./src/store/themestore.ts","./src/stores/itemstore.ts","./node_modules/zustand/esm/vanilla/shallow.d.mts","./node_modules/zustand/esm/react/shallow.d.mts","./node_modules/zustand/esm/shallow.d.mts","./src/stores/masterdatastore.ts","./src/app/[locale]/error.tsx","./node_modules/next-intl/dist/types/shared/nextintlclientprovider.d.ts","./node_modules/next-intl/dist/types/react-client/index.d.ts","./node_modules/next-intl/dist/types/index.react-client.d.ts","./src/contexts/themecontext.tsx","./src/app/[locale]/layout.tsx","./src/app/[locale]/not-found.tsx","./src/app/[locale]/page.tsx","./src/app/[locale]/(protected)/error.tsx","./src/components/ui/sheet.tsx","./node_modules/@radix-ui/react-dropdown-menu/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-menu/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-menu/dist/index.d.mts","./node_modules/@radix-ui/react-dropdown-menu/dist/index.d.mts","./src/components/ui/dropdown-menu.tsx","./src/components/layout/sidebar.tsx","./src/layouts/dashboardlayout.tsx","./src/contexts/rootprovider.tsx","./src/app/[locale]/(protected)/layout.tsx","./src/components/ui/loading-spinner.tsx","./src/app/[locale]/(protected)/loading.tsx","./src/app/[locale]/(protected)/not-found.tsx","./src/components/common/emptypage.tsx","./src/app/[locale]/(protected)/[...slug]/page.tsx","./src/components/ui/chart-wrapper.tsx","./node_modules/recharts/types/container/surface.d.ts","./node_modules/recharts/types/container/layer.d.ts","./node_modules/recharts/types/shape/dot.d.ts","./node_modules/@types/d3-path/index.d.ts","./node_modules/@types/d3-shape/index.d.ts","./node_modules/victory-vendor/d3-shape.d.ts","./node_modules/recharts/types/synchronisation/types.d.ts","./node_modules/recharts/types/chart/types.d.ts","./node_modules/recharts/types/component/defaulttooltipcontent.d.ts","./node_modules/recharts/types/component/text.d.ts","./node_modules/recharts/types/zindex/zindexlayer.d.ts","./node_modules/recharts/types/component/label.d.ts","./node_modules/recharts/types/cartesian/cartesianaxis.d.ts","./node_modules/redux/dist/redux.d.ts","./node_modules/immer/dist/immer.d.ts","./node_modules/reselect/dist/reselect.d.ts","./node_modules/redux-thunk/dist/redux-thunk.d.ts","./node_modules/@reduxjs/toolkit/dist/uncheckedindexed.ts","./node_modules/@reduxjs/toolkit/dist/index.d.mts","./node_modules/recharts/types/state/brushslice.d.ts","./node_modules/recharts/types/context/brushupdatecontext.d.ts","./node_modules/recharts/types/state/chartdataslice.d.ts","./node_modules/recharts/types/animation/easing.d.ts","./node_modules/recharts/types/shape/rectangle.d.ts","./node_modules/recharts/types/component/labellist.d.ts","./node_modules/recharts/types/util/barutils.d.ts","./node_modules/recharts/types/state/types/linesettings.d.ts","./node_modules/recharts/types/state/types/scattersettings.d.ts","./node_modules/recharts/types/shape/curve.d.ts","./node_modules/recharts/types/util/stacks/stacktypes.d.ts","./node_modules/recharts/types/state/selectors/areaselectors.d.ts","./node_modules/recharts/types/cartesian/area.d.ts","./node_modules/recharts/types/state/types/areasettings.d.ts","./node_modules/recharts/types/state/types/radialbarsettings.d.ts","./node_modules/recharts/types/util/svgpropertiesnoevents.d.ts","./node_modules/recharts/types/util/useuniqueid.d.ts","./node_modules/recharts/types/state/types/piesettings.d.ts","./node_modules/recharts/types/state/types/radarsettings.d.ts","./node_modules/recharts/types/state/graphicalitemsslice.d.ts","./node_modules/recharts/types/state/types/stackedgraphicalitem.d.ts","./node_modules/recharts/types/state/types/barsettings.d.ts","./node_modules/recharts/types/cartesian/bar.d.ts","./node_modules/recharts/types/cartesian/line.d.ts","./node_modules/recharts/types/shape/symbols.d.ts","./node_modules/recharts/types/cartesian/scatter.d.ts","./node_modules/recharts/types/cartesian/errorbar.d.ts","./node_modules/recharts/types/state/errorbarslice.d.ts","./node_modules/recharts/types/state/legendslice.d.ts","./node_modules/recharts/types/state/optionsslice.d.ts","./node_modules/recharts/types/state/polaraxisslice.d.ts","./node_modules/recharts/types/state/polaroptionsslice.d.ts","./node_modules/recharts/types/util/ifoverflow.d.ts","./node_modules/recharts/types/util/resolvedefaultprops.d.ts","./node_modules/recharts/types/cartesian/referenceline.d.ts","./node_modules/recharts/types/state/referenceelementsslice.d.ts","./node_modules/recharts/types/state/rootpropsslice.d.ts","./node_modules/recharts/types/state/store.d.ts","./node_modules/recharts/types/cartesian/getticks.d.ts","./node_modules/recharts/types/cartesian/cartesiangrid.d.ts","./node_modules/recharts/types/state/selectors/combiners/combinedisplayedstackeddata.d.ts","./node_modules/recharts/types/state/selectors/selecttooltipaxistype.d.ts","./node_modules/recharts/types/state/selectors/axisselectors.d.ts","./node_modules/recharts/types/state/cartesianaxisslice.d.ts","./node_modules/recharts/types/state/tooltipslice.d.ts","./node_modules/recharts/types/util/chartutils.d.ts","./node_modules/recharts/types/component/dots.d.ts","./node_modules/recharts/types/util/types.d.ts","./node_modules/recharts/types/component/defaultlegendcontent.d.ts","./node_modules/recharts/types/util/payload/getuniqpayload.d.ts","./node_modules/recharts/types/util/useelementoffset.d.ts","./node_modules/recharts/types/component/legend.d.ts","./node_modules/recharts/types/component/cursor.d.ts","./node_modules/recharts/types/component/tooltip.d.ts","./node_modules/recharts/types/component/responsivecontainer.d.ts","./node_modules/recharts/types/component/cell.d.ts","./node_modules/recharts/types/component/customized.d.ts","./node_modules/recharts/types/shape/sector.d.ts","./node_modules/recharts/types/shape/polygon.d.ts","./node_modules/recharts/types/shape/cross.d.ts","./node_modules/recharts/types/polar/polargrid.d.ts","./node_modules/recharts/types/polar/defaultpolarradiusaxisprops.d.ts","./node_modules/recharts/types/polar/polarradiusaxis.d.ts","./node_modules/recharts/types/polar/defaultpolarangleaxisprops.d.ts","./node_modules/recharts/types/polar/polarangleaxis.d.ts","./node_modules/recharts/types/polar/pie.d.ts","./node_modules/recharts/types/polar/radar.d.ts","./node_modules/recharts/types/polar/radialbar.d.ts","./node_modules/recharts/types/cartesian/brush.d.ts","./node_modules/recharts/types/cartesian/referencedot.d.ts","./node_modules/recharts/types/cartesian/referencearea.d.ts","./node_modules/recharts/types/cartesian/xaxis.d.ts","./node_modules/recharts/types/cartesian/yaxis.d.ts","./node_modules/recharts/types/cartesian/zaxis.d.ts","./node_modules/recharts/types/chart/linechart.d.ts","./node_modules/recharts/types/chart/barchart.d.ts","./node_modules/recharts/types/chart/piechart.d.ts","./node_modules/recharts/types/chart/treemap.d.ts","./node_modules/recharts/types/chart/sankey.d.ts","./node_modules/recharts/types/chart/radarchart.d.ts","./node_modules/recharts/types/chart/scatterchart.d.ts","./node_modules/recharts/types/chart/areachart.d.ts","./node_modules/recharts/types/chart/radialbarchart.d.ts","./node_modules/recharts/types/chart/composedchart.d.ts","./node_modules/recharts/types/chart/sunburstchart.d.ts","./node_modules/recharts/types/shape/trapezoid.d.ts","./node_modules/recharts/types/cartesian/funnel.d.ts","./node_modules/recharts/types/chart/funnelchart.d.ts","./node_modules/recharts/types/util/global.d.ts","./node_modules/recharts/types/zindex/defaultzindexes.d.ts","./node_modules/decimal.js-light/decimal.d.ts","./node_modules/recharts/types/util/scale/getnicetickvalues.d.ts","./node_modules/recharts/types/types.d.ts","./node_modules/recharts/types/hooks.d.ts","./node_modules/recharts/types/context/chartlayoutcontext.d.ts","./node_modules/recharts/types/index.d.ts","./src/components/business/maindashboard.tsx","./src/components/business/dashboard.tsx","./src/app/[locale]/(protected)/dashboard/page.tsx","./src/components/items/itemlistclient.tsx","./src/app/[locale]/(protected)/items/page.tsx","./src/components/items/itemdetailclient.tsx","./src/app/[locale]/(protected)/items/[id]/page.tsx","./node_modules/zod/v3/helpers/typealiases.d.cts","./node_modules/zod/v3/helpers/util.d.cts","./node_modules/zod/v3/zoderror.d.cts","./node_modules/zod/v3/locales/en.d.cts","./node_modules/zod/v3/errors.d.cts","./node_modules/zod/v3/helpers/parseutil.d.cts","./node_modules/zod/v3/helpers/enumutil.d.cts","./node_modules/zod/v3/helpers/errorutil.d.cts","./node_modules/zod/v3/helpers/partialutil.d.cts","./node_modules/zod/v3/standard-schema.d.cts","./node_modules/zod/v3/types.d.cts","./node_modules/zod/v3/external.d.cts","./node_modules/zod/v3/index.d.cts","./node_modules/@hookform/resolvers/zod/dist/zod.d.ts","./node_modules/@hookform/resolvers/zod/dist/index.d.ts","./src/components/ui/alert.tsx","./src/components/items/itemtypeselect.tsx","./node_modules/@radix-ui/react-slider/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-slider/dist/index.d.mts","./src/components/ui/slider.tsx","./src/components/items/drawingcanvas.tsx","./src/components/items/itemform/validationalert.tsx","./src/components/items/itemform/formheader.tsx","./src/components/items/itemform/bendingdiagramsection.tsx","./node_modules/cmdk/dist/index.d.ts","./src/components/ui/command.tsx","./src/components/items/itemform/bomsection.tsx","./src/components/items/itemform/index.tsx","./src/app/[locale]/(protected)/items/[id]/edit/page.tsx","./src/app/[locale]/(protected)/items/create/page.tsx","./src/components/organisms/pagelayout.tsx","./src/components/organisms/pageheader.tsx","./src/components/items/itemmasterdatamanagement/dialogs/fielddialog.tsx","./node_modules/vaul/dist/index.d.mts","./src/components/ui/drawer.tsx","./src/components/items/itemmasterdatamanagement/dialogs/fielddrawer.tsx","./node_modules/@radix-ui/react-alert-dialog/dist/index.d.mts","./src/components/ui/alert-dialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/tabmanagementdialogs.tsx","./src/components/items/itemmasterdatamanagement/dialogs/optiondialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/columnmanagedialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/patheditdialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/pagedialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/sectiondialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/masterfielddialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/templatefielddialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/loadtemplatedialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/columndialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/sectiontemplatedialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/importsectiondialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/importfielddialog.tsx","./src/components/common/servererrorpage.tsx","./src/components/items/itemmasterdatamanagement.tsx","./src/app/[locale]/(protected)/master-data/item-master-data-management/page.tsx","./src/app/[locale]/(protected)/production/screen-production/page.tsx","./src/app/[locale]/(protected)/production/screen-production/[id]/page.tsx","./src/app/[locale]/(protected)/production/screen-production/[id]/edit/page.tsx","./src/app/[locale]/(protected)/production/screen-production/create/page.tsx","./src/components/languageselect.tsx","./src/components/themeselect.tsx","./src/components/auth/loginpage.tsx","./src/app/[locale]/login/page.tsx","./src/components/auth/signuppage.tsx","./src/app/[locale]/signup/page.tsx","./src/components/items/fileupload.tsx","./src/components/items/dynamicitemform/dynamicfield.tsx","./src/components/items/dynamicitemform/dynamicsection.tsx","./src/components/items/dynamicitemform/dynamicformrenderer.tsx","./src/components/items/dynamicitemform/index.tsx","./src/components/items/itemformwrapper.tsx","./src/components/ui/error-message.tsx","./node_modules/@radix-ui/react-progress/node_modules/@radix-ui/react-context/dist/index.d.mts","./node_modules/@radix-ui/react-progress/dist/index.d.mts","./src/components/ui/progress.tsx","./node_modules/@radix-ui/react-tooltip/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-tooltip/dist/index.d.mts","./src/components/ui/tooltip.tsx","./src/contexts/_unused/accountingcontext.tsx","./src/contexts/_unused/developermodecontext.tsx","./src/contexts/_unused/facilitiescontext.tsx","./src/contexts/_unused/hrcontext.tsx","./src/contexts/_unused/inventorycontext.tsx","./src/contexts/_unused/pricingcontext.tsx","./src/contexts/_unused/productioncontext.tsx","./src/contexts/_unused/salescontext.tsx","./src/contexts/_unused/shippingcontext.tsx","./.next/types/cache-life.d.ts","./.next/types/server.d.ts","./.next/types/validator.ts","./.next/types/app/[locale]/layout.ts","./.next/types/app/[locale]/(protected)/layout.ts","./.next/types/app/[locale]/(protected)/[...slug]/page.ts","./.next/types/app/[locale]/(protected)/master-data/item-master-data-management/page.ts","./.next/types/app/[locale]/(protected)/production/screen-production/page.ts","./.next/types/app/api/auth/check/route.ts","./.next/types/app/api/proxy/[...path]/route.ts","./node_modules/@types/d3-array/index.d.ts","./node_modules/@types/d3-color/index.d.ts","./node_modules/@types/d3-ease/index.d.ts","./node_modules/@types/d3-interpolate/index.d.ts","./node_modules/@types/d3-time/index.d.ts","./node_modules/@types/d3-scale/index.d.ts","./node_modules/@types/d3-timer/index.d.ts","./node_modules/@types/estree/index.d.ts","./node_modules/@types/json-schema/index.d.ts","./node_modules/@types/json5/index.d.ts","./node_modules/@types/use-sync-external-store/index.d.ts"],"fileIdsList":[[100,146,337,1349],[100,146,337,1344],[100,146,337,1526],[100,146,337,1527],[100,146,337,1331],[100,146,491,520],[100,146,491,525],[100,146,444,445,446,447],[100,146],[100,145,146,275,277,278,280,328,432,482,483,484,487,488,490],[83,100,146,491,494,520,521,522,523,524,525,527,528,1331,1333,1344,1349,1468,1470,1472,1501,1502,1526,1527,1528,1529,1530,1534,1536],[100,146,509],[83,100,146,495,496],[100,146,495,501],[100,146,934],[100,146,935],[100,146,934,935,936,937,938,939,940],[100,146,1212],[100,146,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246],[100,146,1212,1215],[100,146,1215],[100,146,1213],[100,146,1212,1213,1214],[100,146,1213,1215],[100,146,1213,1214],[100,146,1251],[100,146,1251,1253,1254],[100,146,1251,1252],[100,146,1247,1250],[100,146,1248,1249],[100,146,1247],[100,146,1486],[100,146,1099,1141,1485],[100,146,508],[86,100,146,535,1185],[86,100,146,536],[86,100,146],[86,100,146,262,535,536],[86,100,146,535,536,545,547,554],[86,100,146,535,536,1338],[86,100,146,574],[86,100,146,535,536,545,547,552,554,562],[86,100,146,1014,1015,1016,1017,1020,1021],[86,100,146,1015],[86,100,146,1014,1015,1018,1019],[86,100,146,535,536,549,551],[86,100,146,574,1544],[86,100,146,535,536],[86,100,146,535,536,545,547,552,554],[86,90,100,146,195,196,197,198,199,439,487],[86,100,146,535,536,562],[86,100,146,535,536,545,552,554],[100,146,1364,1365,1366,1367,1368],[100,146,1570],[100,146,1573],[100,146,1354],[100,143,146],[100,145,146],[146],[100,146,151,179],[100,146,147,152,157,165,176,187],[100,146,147,148,157,165],[95,96,97,100,146],[100,146,149,188],[100,146,150,151,158,166],[100,146,151,176,184],[100,146,152,154,157,165],[100,145,146,153],[100,146,154,155],[100,146,156,157],[100,145,146,157],[100,146,157,158,159,176,187],[100,146,157,158,159,172,176,179],[100,146,154,157,160,165,176,187],[100,146,157,158,160,161,165,176,184,187],[100,146,160,162,176,184,187],[98,99,100,101,102,103,104,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],[100,146,157,163],[100,146,164,187,192],[100,146,154,157,165,176],[100,146,166],[100,146,167],[100,145,146,168],[100,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],[100,146,170],[100,146,171],[100,146,157,172,173],[100,146,172,174,188,190],[100,146,157,176,177,179],[100,146,178,179],[100,146,176,177],[100,146,179],[100,146,180],[100,143,146,176,181],[100,146,157,182,183],[100,146,182,183],[100,146,151,165,176,184],[100,146,185],[100,146,165,186],[100,146,160,171,187],[100,146,151,188],[100,146,176,189],[100,146,164,190],[100,146,191],[100,141,146],[100,141,146,157,159,168,176,179,187,190,192],[100,146,176,193],[86,90,100,146,195,196,197,199,439,487,540],[86,90,100,146,195,196,197,198,354,439,487,540],[86,90,100,146,195,196,198,199,439,487,540],[86,100,146,199,354,355],[86,100,146,199,354],[86,90,100,146,196,197,198,199,439,487,540],[86,90,100,146,195,197,198,199,439,487,540],[84,85,100,146],[100,146,529,541],[100,146,529],[86,100,146,1185],[100,146,583],[100,146,581,583],[100,146,581],[100,146,583,647,648],[100,146,583,650],[100,146,583,651],[100,146,668],[100,146,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836],[100,146,583,744],[100,146,581,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932],[100,146,583,648,768],[100,146,581,765,766],[100,146,767],[100,146,583,765],[100,146,580,581,582],[100,146,1256,1257,1258],[100,146,1255,1256],[100,146,1247,1255],[100,146,1328],[100,146,515],[100,146,514],[100,146,491,512,513],[100,146,500],[100,146,495,498],[100,146,499],[100,146,1290,1327],[100,146,491,512],[100,146,1298],[100,146,1278],[100,146,1290],[100,146,1290,1294],[100,146,1279,1280,1291,1292,1293,1295,1296,1297],[86,100,146,262,1289,1290],[92,100,146],[100,146,442],[100,146,449],[100,146,203,217,218,219,221,436],[100,146,203,242,244,246,247,250,436,438],[100,146,203,207,209,210,211,212,213,425,436,438],[100,146,436],[100,146,218,320,406,415,432],[100,146,203],[100,146,200,432],[100,146,254],[100,146,253,436,438],[100,146,160,302,320,349,493],[100,146,160,313,329,415,431],[100,146,160,367],[100,146,419],[100,146,418,419,420],[100,146,418],[94,100,146,160,200,203,207,210,214,215,216,218,222,230,231,360,385,416,436,439],[100,146,203,220,238,242,243,248,249,436,493],[100,146,220,493],[100,146,231,238,300,436,493],[100,146,493],[100,146,203,220,221,493],[100,146,245,493],[100,146,214,417,424],[100,146,171,262,432],[100,146,262,432],[86,100,146,262],[86,100,146,321],[100,146,317,365,432,475,476],[100,146,412,469,470,471,472,474],[100,146,411],[100,146,411,412],[100,146,211,361,362,363],[100,146,361,364,365],[100,146,473],[100,146,361,365],[86,100,146,204,463],[86,100,146,187],[86,100,146,220,290],[86,100,146,220],[100,146,288,292],[86,100,146,289,441],[86,90,100,146,160,194,195,196,197,198,199,439,485,486,540],[100,146,160],[100,146,160,207,269,361,371,386,406,421,422,436,437,493],[100,146,230,423],[100,146,439],[100,146,202],[86,100,146,302,316,328,338,340,431],[100,146,171,302,316,337,338,339,431,492],[100,146,331,332,333,334,335,336],[100,146,333],[100,146,337],[100,146,260,261,262,264],[86,100,146,255,256,257,263],[100,146,260,263],[100,146,258],[100,146,259],[86,100,146,262,289,441],[86,100,146,262,440,441],[86,100,146,262,441],[100,146,386,428],[100,146,428],[100,146,160,437,441],[100,146,325],[100,145,146,324],[100,146,232,270,308,310,312,313,314,315,358,361,431,434,437],[100,146,232,346,361,365],[100,146,313,431],[86,100,146,313,322,323,325,326,327,328,329,330,341,342,343,344,345,347,348,431,432,493],[100,146,307],[100,146,160,171,232,233,269,284,314,358,359,360,365,386,406,427,436,437,438,439,493],[100,146,431],[100,145,146,218,311,314,360,427,429,430,437],[100,146,313],[100,145,146,269,274,303,304,305,306,307,308,309,310,312,431,432],[100,146,160,274,275,303,437,438],[100,146,218,360,361,386,427,431,437],[100,146,160,436,438],[100,146,160,176,434,437,438],[100,146,160,171,187,200,207,220,232,233,235,270,271,276,281,284,310,314,361,371,373,376,378,381,382,383,384,385,406,426,427,432,434,436,437,438],[100,146,160,176],[100,146,203,204,205,207,212,215,220,238,426,434,435,439,441,493],[100,146,160,176,187,250,252,254,255,256,257,264,493],[100,146,171,187,200,242,252,280,281,282,283,310,361,376,385,386,392,395,396,406,427,432,434],[100,146,214,215,230,360,385,427,436],[100,146,160,187,204,207,310,390,434,436],[100,146,301],[100,146,160,393,394,403],[100,146,434,436],[100,146,308,311],[100,146,310,314,426,441],[100,146,160,171,236,242,283,376,386,392,395,398,434],[100,146,160,214,230,242,399],[100,146,203,235,401,426,436],[100,146,160,187,436],[100,146,160,220,234,235,236,247,265,400,402,426,436],[94,100,146,232,314,405,439,441],[100,146,160,171,187,207,214,222,230,233,270,276,280,281,282,283,284,310,361,373,386,387,389,391,406,426,427,432,433,434,441],[100,146,160,176,214,392,397,403,434],[100,146,225,226,227,228,229],[100,146,271,377],[100,146,379],[100,146,377],[100,146,379,380],[100,146,160,207,210,211,269,437],[100,146,160,171,202,204,232,270,284,314,369,370,406,434,438,439,441],[100,146,160,171,187,206,211,310,370,433,437],[100,146,303],[100,146,304],[100,146,305],[100,146,432],[100,146,251,267],[100,146,160,207,251,270],[100,146,266,267],[100,146,268],[100,146,251,252],[100,146,251,285],[100,146,251],[100,146,271,375,433],[100,146,374],[100,146,252,432,433],[100,146,372,433],[100,146,252,432],[100,146,358],[100,146,207,212,270,299,302,308,310,314,316,319,350,353,357,361,405,426,434,437],[100,146,293,296,297,298,317,318,365],[86,100,146,197,199,262,351,352],[86,100,146,197,199,262,351,352,356],[100,146,414],[100,146,218,275,313,314,325,329,361,405,407,408,409,410,412,413,416,426,431,436],[100,146,365],[100,146,369],[100,146,160,270,286,366,368,371,405,434,439,441],[100,146,293,294,295,296,297,298,317,318,365,440],[94,100,146,160,171,187,233,251,252,284,310,314,403,404,406,426,427,436,437,439],[100,146,275,277,280,427],[100,146,160,271,436],[100,146,274,313],[100,146,273],[100,146,275,276],[100,146,272,274,436],[100,146,160,206,275,277,278,279,436,437],[86,100,146,361,362,364],[100,146,237],[86,100,146,204],[86,100,146,432],[86,94,100,146,284,314,439,441],[100,146,204,463,464],[86,100,146,292],[86,100,146,171,187,202,249,287,289,291,441],[100,146,220,432,437],[100,146,388,432],[100,146,361],[86,100,146,158,160,171,202,238,244,292,439,440],[86,100,146,195,196,197,198,199,439,487,540],[86,87,88,89,90,100,146],[100,146,151],[100,146,239,240,241],[100,146,239],[86,90,100,146,160,162,171,194,195,196,197,198,199,200,202,233,337,398,436,438,441,487,540],[100,146,451],[100,146,453],[100,146,455],[100,146,457],[100,146,459,460,461],[100,146,465],[91,93,100,146,443,448,450,452,454,456,458,462,466,468,478,479,481,491,492,493,494],[100,146,467],[100,146,477],[100,146,289],[100,146,480],[100,145,146,275,277,278,280,328,432,482,483,484,487,488,489,490],[100,146,194],[100,146,505],[100,146,147,158,176,503,504],[100,146,507],[100,146,506],[100,146,998],[100,146,960],[100,146,999],[100,146,837,865,933,997],[100,146,960,961,998,999],[100,146,942,943,944,945,946,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987],[86,100,146,966,1000],[86,100,146,966],[86,100,146,961],[86,100,146,1000],[86,100,146,969],[100,146,989,990,991,992,993,994,995],[100,146,966],[100,146,1002],[100,146,941,958,959,964,966,988,996,1000,1001,1003,1011],[100,146,947,948,949,950,951,952,953,954,955,956,957],[100,146,966,998],[100,146,945,946,958,959,962,964,997],[100,146,962,963,965,997],[86,100,146,959,997,998],[100,146,962,997],[86,100,146,958,959,988,996],[86,100,146,961,962,963,997,999],[100,146,1004,1005,1006,1007,1008,1009,1010],[86,100,146,1125],[100,146,1125,1126,1127,1130,1131,1132,1133,1134,1135,1136,1139,1140],[100,146,1125],[100,146,1128,1129],[86,100,146,1123,1125],[100,146,1120,1121,1123],[100,146,1116,1119,1121,1123],[100,146,1120,1123],[86,100,146,1111,1112,1113,1116,1117,1118,1120,1121,1122,1123],[100,146,1113,1116,1117,1118,1119,1120,1121,1122,1123,1124],[100,146,1120],[100,146,1114,1120,1121],[100,146,1114,1115],[100,146,1119,1121,1122],[100,146,1119],[100,146,1111,1116,1121,1122],[100,146,1137,1138],[86,100,146,1361,1372,1379,1381,1383,1412,1417],[86,100,146,1356,1361,1373,1374,1375,1376,1391,1412,1415,1417],[86,100,146,1371,1417],[86,100,146,1360,1361,1362,1413,1415,1417],[86,100,146,1361,1408,1413,1415,1417],[86,100,146,1361,1392,1393,1395,1417],[86,100,146,1375,1414,1417,1455],[100,146,1413,1417],[86,100,146,1361,1375,1379,1412,1413,1417],[86,100,146,1361,1362,1374,1402],[86,100,146,1353,1361,1362,1402],[86,100,146,1361,1362,1402,1403,1417],[86,100,146,1359,1361,1375,1378,1379,1394,1412,1413,1414,1417],[86,100,146,1413,1417],[86,100,146,1413,1415,1417],[86,100,146,1412,1415,1417],[86,100,146,1417],[86,100,146,1374,1414,1417],[86,100,146,1414,1417],[86,100,146,1357],[86,100,146,1361,1414,1417],[86,100,146,1353,1361,1417],[86,100,146,1360,1361,1417],[86,100,146,1361,1362,1417,1465],[86,100,146,1418,1419,1420],[86,100,146,1358,1359,1413,1414,1417,1419,1422],[100,146,1407,1417],[100,146,1412,1413,1417,1462],[100,146,1351,1352,1353,1357,1359,1360,1361,1362,1363,1374,1375,1379,1382,1392,1393,1394,1395,1396,1402,1404,1409,1417,1418,1421,1423,1424,1425,1426,1427,1428,1429,1430,1432,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1461,1462,1463,1464],[86,100,146,1361,1375,1385,1387,1414,1417],[86,100,146,1360,1361,1403,1415,1417,1433],[86,100,146,1361,1413],[86,100,146,1361,1403,1417,1431],[86,100,146,1361,1415,1417],[86,100,146,1356,1361,1372,1375,1412,1413,1415,1417,1427],[86,100,146,1356,1417],[86,100,146,1373,1417],[100,146,1364,1369,1417],[100,146,1363,1364,1369,1412,1415,1417],[100,146,1364,1369,1371],[100,146,1364,1369,1389,1396,1417],[100,146,1364,1369,1372,1377,1378,1383,1384,1387,1388,1391,1413,1417],[100,146,1364,1369,1417,1418,1421],[100,146,1364,1369,1414,1417],[100,146,1364,1369,1413],[100,146,1364,1369],[100,146,1364,1365,1369,1402,1404,1413],[100,146,1357,1364,1369,1382,1417],[100,146,1356,1380,1389,1407,1413,1417],[100,146,1364,1366,1370,1372,1380,1389,1390,1397,1398,1399,1400,1401,1405,1406,1407,1409,1410,1411,1413,1414,1415,1417,1465],[100,146,1372,1380,1390,1413],[100,146,1407],[100,146,1364,1369,1370,1372,1389,1397,1398,1399,1400,1401,1405,1406,1413,1414,1417,1465],[100,146,1358,1359,1364,1369,1413,1417],[100,146,1372,1382,1389,1390,1417],[100,146,1376,1389,1390],[100,146,1372,1389,1417],[86,100,146,1359,1385,1386,1389,1417],[100,146,1389],[100,146,1389,1390],[100,146,1359,1372,1389,1417],[100,146,1389,1415,1417],[100,146,1414,1417],[86,100,146,1374,1392,1417],[100,146,1356,1359,1380,1398,1412,1414,1417],[100,146,1417,1460],[100,146,1356,1389,1390,1415],[86,100,146,1353,1357,1358,1382,1385,1412,1415,1416],[100,146,1364],[100,146,176,194],[100,113,117,146,187],[100,113,146,176,187],[100,108,146],[100,110,113,146,184,187],[100,146,165,184],[100,108,146,194],[100,110,113,146,165,187],[100,105,106,109,112,146,157,176,187],[100,113,120,146],[100,105,111,146],[100,113,134,135,146],[100,109,113,146,179,187,194],[100,134,146,194],[100,107,108,146,194],[100,113,146],[100,107,108,109,110,111,112,113,114,115,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,135,136,137,138,139,140,146],[100,113,128,146],[100,113,120,121,146],[100,111,113,121,122,146],[100,112,146],[100,105,108,113,146],[100,113,117,121,122,146],[100,117,146],[100,111,113,116,146,187],[100,105,110,113,120,146],[100,146,176],[100,108,113,134,146,192,194],[100,146,1277],[86,100,146,1199,1200,1260,1261,1262,1264,1271,1273],[86,100,146,1198,1261,1265,1266,1268,1269,1270,1271],[100,146,1199],[100,146,1200,1260],[100,146,1259],[100,146,1262],[100,146,1267],[100,146,1197,1198,1199,1200,1260,1261,1262,1263,1264,1266,1268,1269,1270,1271,1272,1273,1274,1275,1276],[100,146,1264,1266],[100,146,1199,1261,1262,1264,1265],[100,146,1263],[100,146,1278,1289],[100,146,1288],[100,146,1281,1282,1283,1284,1285,1286,1287],[86,100,146,262,1266],[100,146,1274],[100,146,1262,1270,1272],[100,146,1355],[100,146,1107],[100,146,1475,1476],[100,146,1473,1474,1475,1477,1478,1483],[100,146,1474,1475],[100,146,1483],[100,146,1484],[100,146,1475],[100,146,1473,1474,1475,1478,1479,1480,1481,1482],[100,146,1473,1474,1485],[100,146,1099],[100,146,1099,1102],[100,146,1093,1099,1100,1101,1102,1103,1104,1105,1106],[100,146,1099,1100],[100,146,1099,1101],[100,146,1038,1040,1041,1042,1043],[100,146,1038,1040,1042,1043],[100,146,1038,1040,1042],[100,146,1037,1038,1040,1041,1043],[100,146,1038,1039,1040,1041,1042,1043,1044,1045,1093,1094,1095,1096,1097,1098],[100,146,1040,1043],[100,146,1037,1038,1039,1041,1042,1043],[100,146,1040,1094,1097],[100,146,1040,1041,1042,1043],[100,146,1042],[100,146,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092],[100,146,1307,1308,1310,1311,1312,1314],[100,146,1310,1311,1312,1313,1314],[100,146,1307,1310,1311,1312,1314],[100,146,1322,1323],[86,100,146,478,1348],[100,146,1467],[86,100,146,468,534,538,543],[86,100,146,478,571,1109,1500],[86,100,146,478,571,1471],[100,146,1109,1500],[86,100,146,571,1469],[100,146,1194,1342,1343],[100,146,1345],[86,100,146,495,1525],[100,146,468,534,538,543],[100,146,478,495,517,1299,1329,1330],[100,146,1533],[86,100,146,478],[100,146,1535],[100,146,1560],[100,146,526,1560],[86,100,146,478,538,543,566,576,1317,1329,1531,1532],[86,100,146,478,538,543,557,566,576,1318,1329,1531,1532],[86,100,146,1345,1466],[86,100,146,534,538,539,543,557,1013,1168,1195,1350,1465],[86,100,146,531,532,534,538,539,543,558,559,565,567],[100,146,558,559,565,567,568,569],[100,146,538,543,557,558],[100,146,538,557,558,566],[100,146,534,558],[100,146,558,564],[86,100,146,538],[100,146,478,534,538,543],[86,100,146,534,538,543,557,566,576,1166,1168,1171,1189],[86,100,146,538,543,576,1189,1492],[100,146,572,1031],[100,146,572,1033,1539],[86,100,146,531,534,538,543,572,1538],[100,146,531,539,572,576,1027],[86,100,146,531,534,538,543,566,571,572,576],[86,100,146,531,538,543,572,576,837,933,1013,1023],[86,100,146,531,557,572,576],[86,100,146,531,538,543,572,576],[100,146,577,578,579,1024,1028,1029,1030],[86,100,146,531,566,572,576],[100,146,531,566,572,573,576],[100,146,1032,1033,1034],[86,100,146,572],[86,100,146,571,572],[86,100,146,538,543,571,572,1035,1488,1538,1539,1540],[100,146,571],[86,100,146,538,543,566,576],[100,146,478,532,534,538,543,571,576,1168],[100,146,534,538,543,566,571,576,1109,1141],[86,100,146,532,534,538,543,566,571,576,1023,1110,1168,1498],[100,146,1145],[86,100,146,571,1109,1141,1142,1143,1144],[100,146,538,543,571],[100,146,1147,1148,1153],[100,146,557,566,571,576,1109,1141],[100,146,557,576,1109,1141,1152],[100,146,539,557,566,576,1109,1141],[100,146,557,566,576,1036,1109,1141],[100,146,1149,1150,1151],[100,146,539,557,566,576,1036,1109,1141],[100,146,538,539,543,557,566,573,576,1109,1141],[100,146,1142,1143,1144],[86,100,146,571,1109,1141],[86,100,146,571],[86,100,146,478,534,566,571,576,1036,1109,1110,1141,1154,1155,1487,1488,1489,1493,1494,1495,1496,1499],[100,146,571,1109],[100,146,1036,1109,1141,1488],[86,100,146,571,572,1109,1500,1541],[86,100,146,478,532,534,538,539,543,557,564,566,571,1168],[86,100,146,534,538,543,564,1162,1164,1165,1166,1168,1171,1181,1193,1345,1503,1504,1505,1508,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524],[100,146,538,543,566,576,1027,1166,1168,1171],[86,100,146,538,543,1166,1168],[86,100,146,538,543,566,1166],[100,146,1167,1169],[86,100,146,543,566,576,1171,1189],[100,146,538,543,557,566,576,1027,1156,1168,1171,1189],[86,100,146,538,543,557,566,573,576,1027,1166,1168,1171,1175,1189],[100,146,538,543,557,566,573,576,1027,1166,1168,1171,1507],[86,100,146,538,543,566,576,1160,1166,1168,1189],[100,146,538,543,1166,1168,1189],[86,100,146,543,557,566,573,576,1027,1168,1189],[86,100,146,543,557,566,576,1027,1189],[86,100,146,543,557,566,576,1189],[86,100,146,538,543,566,573,576,1166,1189],[86,100,146,543,557,566,573,576,1189],[100,146,538,543,566,576,1168,1189,1510],[86,100,146,538,543,557,566,573,576,1027,1166,1168,1189],[100,146,1173,1174,1176,1177,1178,1179,1180],[86,100,146,1156,1166,1171],[86,100,146,1166,1171,1175],[86,100,146,1166,1171],[86,100,146,1162,1166,1171,1172],[86,100,146,538,1166,1171],[100,146,534,538,543,566,1168,1171],[86,100,146,534,538,543,566,1166,1170,1171,1190],[100,146,1182,1183,1191,1192],[100,146,534,538,543,1166,1168],[86,100,146,534,538,543,564,1166,1168,1190],[100,146,557,571,576],[100,146,478,538,557,1329],[86,100,146,538,1316],[100,146,538,557,1330],[86,100,146,533,543,1509],[86,100,146,533,542],[86,100,146,533,540,542],[86,100,146,531,540,542],[86,100,146,533,538,543,1012],[86,100,146,533],[86,100,146,533,537,538],[86,100,146,533,538,1189,1497],[86,100,146,533,538,1185,1188],[86,100,146,533,1506],[86,100,146,533,538,1339],[86,100,146,538,1488],[86,100,146,531],[86,100,146,531,575],[86,100,146,533,1022],[86,100,146,533,1545],[86,100,146,531,538,556],[86,100,146,533,538,1185],[86,100,146,531,1491],[86,100,146,533,1026],[86,100,146,531,563],[86,100,146,533,1548],[100,146,529,530],[86,100,146,1187],[86,100,146,1157,1159,1160,1162,1164,1165],[86,100,146,1157,1166],[100,146,517,1299],[86,100,146,478,538,543,566,1316,1317,1330,1335,1340,1341],[100,146,518,1301],[100,146,1160,1161,1162,1163],[100,146,571,1559],[100,146,1304,1559],[100,146,1160,1166],[100,146,1158],[100,146,538,1316],[100,146,571,1108],[100,146,1108],[100,146,516,517,518,1560],[100,146,1309,1315],[100,146,538,1309,1315],[100,146,571,1309,1315],[100,146,1304,1305,1309,1315,1324]],"fileInfos":[{"version":"c430d44666289dae81f30fa7b2edebf186ecc91a2d4c71266ea6ae76388792e1","affectsGlobalScope":true,"impliedFormat":1},{"version":"45b7ab580deca34ae9729e97c13cfd999df04416a79116c3bfb483804f85ded4","impliedFormat":1},{"version":"3facaf05f0c5fc569c5649dd359892c98a85557e3e0c847964caeb67076f4d75","impliedFormat":1},{"version":"e44bb8bbac7f10ecc786703fe0a6a4b952189f908707980ba8f3c8975a760962","impliedFormat":1},{"version":"5e1c4c362065a6b95ff952c0eab010f04dcd2c3494e813b493ecfd4fcb9fc0d8","impliedFormat":1},{"version":"68d73b4a11549f9c0b7d352d10e91e5dca8faa3322bfb77b661839c42b1ddec7","impliedFormat":1},{"version":"5efce4fc3c29ea84e8928f97adec086e3dc876365e0982cc8479a07954a3efd4","impliedFormat":1},{"version":"feecb1be483ed332fad555aff858affd90a48ab19ba7272ee084704eb7167569","impliedFormat":1},{"version":"ee7bad0c15b58988daa84371e0b89d313b762ab83cb5b31b8a2d1162e8eb41c2","impliedFormat":1},{"version":"27bdc30a0e32783366a5abeda841bc22757c1797de8681bbe81fbc735eeb1c10","impliedFormat":1},{"version":"8fd575e12870e9944c7e1d62e1f5a73fcf23dd8d3a321f2a2c74c20d022283fe","impliedFormat":1},{"version":"2ab096661c711e4a81cc464fa1e6feb929a54f5340b46b0a07ac6bbf857471f0","impliedFormat":1},{"version":"080941d9f9ff9307f7e27a83bcd888b7c8270716c39af943532438932ec1d0b9","affectsGlobalScope":true,"impliedFormat":1},{"version":"2e80ee7a49e8ac312cc11b77f1475804bee36b3b2bc896bead8b6e1266befb43","affectsGlobalScope":true,"impliedFormat":1},{"version":"c57796738e7f83dbc4b8e65132f11a377649c00dd3eee333f672b8f0a6bea671","affectsGlobalScope":true,"impliedFormat":1},{"version":"dc2df20b1bcdc8c2d34af4926e2c3ab15ffe1160a63e58b7e09833f616efff44","affectsGlobalScope":true,"impliedFormat":1},{"version":"515d0b7b9bea2e31ea4ec968e9edd2c39d3eebf4a2d5cbd04e88639819ae3b71","affectsGlobalScope":true,"impliedFormat":1},{"version":"0559b1f683ac7505ae451f9a96ce4c3c92bdc71411651ca6ddb0e88baaaad6a3","affectsGlobalScope":true,"impliedFormat":1},{"version":"0dc1e7ceda9b8b9b455c3a2d67b0412feab00bd2f66656cd8850e8831b08b537","affectsGlobalScope":true,"impliedFormat":1},{"version":"ce691fb9e5c64efb9547083e4a34091bcbe5bdb41027e310ebba8f7d96a98671","affectsGlobalScope":true,"impliedFormat":1},{"version":"8d697a2a929a5fcb38b7a65594020fcef05ec1630804a33748829c5ff53640d0","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ff2a353abf8a80ee399af572debb8faab2d33ad38c4b4474cff7f26e7653b8d","affectsGlobalScope":true,"impliedFormat":1},{"version":"fb0f136d372979348d59b3f5020b4cdb81b5504192b1cacff5d1fbba29378aa1","affectsGlobalScope":true,"impliedFormat":1},{"version":"d15bea3d62cbbdb9797079416b8ac375ae99162a7fba5de2c6c505446486ac0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"68d18b664c9d32a7336a70235958b8997ebc1c3b8505f4f1ae2b7e7753b87618","affectsGlobalScope":true,"impliedFormat":1},{"version":"eb3d66c8327153d8fa7dd03f9c58d351107fe824c79e9b56b462935176cdf12a","affectsGlobalScope":true,"impliedFormat":1},{"version":"38f0219c9e23c915ef9790ab1d680440d95419ad264816fa15009a8851e79119","affectsGlobalScope":true,"impliedFormat":1},{"version":"69ab18c3b76cd9b1be3d188eaf8bba06112ebbe2f47f6c322b5105a6fbc45a2e","affectsGlobalScope":true,"impliedFormat":1},{"version":"a680117f487a4d2f30ea46f1b4b7f58bef1480456e18ba53ee85c2746eeca012","affectsGlobalScope":true,"impliedFormat":1},{"version":"2f11ff796926e0832f9ae148008138ad583bd181899ab7dd768a2666700b1893","affectsGlobalScope":true,"impliedFormat":1},{"version":"4de680d5bb41c17f7f68e0419412ca23c98d5749dcaaea1896172f06435891fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"954296b30da6d508a104a3a0b5d96b76495c709785c1d11610908e63481ee667","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac9538681b19688c8eae65811b329d3744af679e0bdfa5d842d0e32524c73e1c","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a969edff4bd52585473d24995c5ef223f6652d6ef46193309b3921d65dd4376","affectsGlobalScope":true,"impliedFormat":1},{"version":"9e9fbd7030c440b33d021da145d3232984c8bb7916f277e8ffd3dc2e3eae2bdb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811ec78f7fefcabbda4bfa93b3eb67d9ae166ef95f9bff989d964061cbf81a0c","affectsGlobalScope":true,"impliedFormat":1},{"version":"717937616a17072082152a2ef351cb51f98802fb4b2fdabd32399843875974ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"d7e7d9b7b50e5f22c915b525acc5a49a7a6584cf8f62d0569e557c5cfc4b2ac2","affectsGlobalScope":true,"impliedFormat":1},{"version":"71c37f4c9543f31dfced6c7840e068c5a5aacb7b89111a4364b1d5276b852557","affectsGlobalScope":true,"impliedFormat":1},{"version":"576711e016cf4f1804676043e6a0a5414252560eb57de9faceee34d79798c850","affectsGlobalScope":true,"impliedFormat":1},{"version":"89c1b1281ba7b8a96efc676b11b264de7a8374c5ea1e6617f11880a13fc56dc6","affectsGlobalScope":true,"impliedFormat":1},{"version":"74f7fa2d027d5b33eb0471c8e82a6c87216223181ec31247c357a3e8e2fddc5b","affectsGlobalScope":true,"impliedFormat":1},{"version":"d6d7ae4d1f1f3772e2a3cde568ed08991a8ae34a080ff1151af28b7f798e22ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"063600664504610fe3e99b717a1223f8b1900087fab0b4cad1496a114744f8df","affectsGlobalScope":true,"impliedFormat":1},{"version":"934019d7e3c81950f9a8426d093458b65d5aff2c7c1511233c0fd5b941e608ab","affectsGlobalScope":true,"impliedFormat":1},{"version":"52ada8e0b6e0482b728070b7639ee42e83a9b1c22d205992756fe020fd9f4a47","affectsGlobalScope":true,"impliedFormat":1},{"version":"3bdefe1bfd4d6dee0e26f928f93ccc128f1b64d5d501ff4a8cf3c6371200e5e6","affectsGlobalScope":true,"impliedFormat":1},{"version":"59fb2c069260b4ba00b5643b907ef5d5341b167e7d1dbf58dfd895658bda2867","affectsGlobalScope":true,"impliedFormat":1},{"version":"639e512c0dfc3fad96a84caad71b8834d66329a1f28dc95e3946c9b58176c73a","affectsGlobalScope":true,"impliedFormat":1},{"version":"368af93f74c9c932edd84c58883e736c9e3d53cec1fe24c0b0ff451f529ceab1","affectsGlobalScope":true,"impliedFormat":1},{"version":"af3dd424cf267428f30ccfc376f47a2c0114546b55c44d8c0f1d57d841e28d74","affectsGlobalScope":true,"impliedFormat":1},{"version":"995c005ab91a498455ea8dfb63aa9f83fa2ea793c3d8aa344be4a1678d06d399","affectsGlobalScope":true,"impliedFormat":1},{"version":"959d36cddf5e7d572a65045b876f2956c973a586da58e5d26cde519184fd9b8a","affectsGlobalScope":true,"impliedFormat":1},{"version":"965f36eae237dd74e6cca203a43e9ca801ce38824ead814728a2807b1910117d","affectsGlobalScope":true,"impliedFormat":1},{"version":"3925a6c820dcb1a06506c90b1577db1fdbf7705d65b62b99dce4be75c637e26b","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a3d63ef2b853447ec4f749d3f368ce642264246e02911fcb1590d8c161b8005","affectsGlobalScope":true,"impliedFormat":1},{"version":"8cdf8847677ac7d20486e54dd3fcf09eda95812ac8ace44b4418da1bbbab6eb8","affectsGlobalScope":true,"impliedFormat":1},{"version":"8444af78980e3b20b49324f4a16ba35024fef3ee069a0eb67616ea6ca821c47a","affectsGlobalScope":true,"impliedFormat":1},{"version":"3287d9d085fbd618c3971944b65b4be57859f5415f495b33a6adc994edd2f004","affectsGlobalScope":true,"impliedFormat":1},{"version":"b4b67b1a91182421f5df999988c690f14d813b9850b40acd06ed44691f6727ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"df83c2a6c73228b625b0beb6669c7ee2a09c914637e2d35170723ad49c0f5cd4","affectsGlobalScope":true,"impliedFormat":1},{"version":"436aaf437562f276ec2ddbee2f2cdedac7664c1e4c1d2c36839ddd582eeb3d0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e3c06ea092138bf9fa5e874a1fdbc9d54805d074bee1de31b99a11e2fec239d","affectsGlobalScope":true,"impliedFormat":1},{"version":"87dc0f382502f5bbce5129bdc0aea21e19a3abbc19259e0b43ae038a9fc4e326","affectsGlobalScope":true,"impliedFormat":1},{"version":"b1cb28af0c891c8c96b2d6b7be76bd394fddcfdb4709a20ba05a7c1605eea0f9","affectsGlobalScope":true,"impliedFormat":1},{"version":"2fef54945a13095fdb9b84f705f2b5994597640c46afeb2ce78352fab4cb3279","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac77cb3e8c6d3565793eb90a8373ee8033146315a3dbead3bde8db5eaf5e5ec6","affectsGlobalScope":true,"impliedFormat":1},{"version":"56e4ed5aab5f5920980066a9409bfaf53e6d21d3f8d020c17e4de584d29600ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ece9f17b3866cc077099c73f4983bddbcb1dc7ddb943227f1ec070f529dedd1","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a6282c8827e4b9a95f4bf4f5c205673ada31b982f50572d27103df8ceb8013c","affectsGlobalScope":true,"impliedFormat":1},{"version":"1c9319a09485199c1f7b0498f2988d6d2249793ef67edda49d1e584746be9032","affectsGlobalScope":true,"impliedFormat":1},{"version":"e3a2a0cee0f03ffdde24d89660eba2685bfbdeae955a6c67e8c4c9fd28928eeb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811c71eee4aa0ac5f7adf713323a5c41b0cf6c4e17367a34fbce379e12bbf0a4","affectsGlobalScope":true,"impliedFormat":1},{"version":"51ad4c928303041605b4d7ae32e0c1ee387d43a24cd6f1ebf4a2699e1076d4fa","affectsGlobalScope":true,"impliedFormat":1},{"version":"60037901da1a425516449b9a20073aa03386cce92f7a1fd902d7602be3a7c2e9","affectsGlobalScope":true,"impliedFormat":1},{"version":"d4b1d2c51d058fc21ec2629fff7a76249dec2e36e12960ea056e3ef89174080f","affectsGlobalScope":true,"impliedFormat":1},{"version":"22adec94ef7047a6c9d1af3cb96be87a335908bf9ef386ae9fd50eeb37f44c47","affectsGlobalScope":true,"impliedFormat":1},{"version":"196cb558a13d4533a5163286f30b0509ce0210e4b316c56c38d4c0fd2fb38405","affectsGlobalScope":true,"impliedFormat":1},{"version":"73f78680d4c08509933daf80947902f6ff41b6230f94dd002ae372620adb0f60","affectsGlobalScope":true,"impliedFormat":1},{"version":"c5239f5c01bcfa9cd32f37c496cf19c61d69d37e48be9de612b541aac915805b","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e7f8264d0fb4c5339605a15daadb037bf238c10b654bb3eee14208f860a32ea","affectsGlobalScope":true,"impliedFormat":1},{"version":"782dec38049b92d4e85c1585fbea5474a219c6984a35b004963b00beb1aab538","affectsGlobalScope":true,"impliedFormat":1},{"version":"023a61743079dd96f914f6e04f8dbd1b4535c1e6c1a489cc889f4f1fa749fc5f","affectsGlobalScope":true},{"version":"170d4db14678c68178ee8a3d5a990d5afb759ecb6ec44dbd885c50f6da6204f6","affectsGlobalScope":true,"impliedFormat":1},{"version":"8a8eb4ebffd85e589a1cc7c178e291626c359543403d58c9cd22b81fab5b1fb9","impliedFormat":1},{"version":"0ff1b165090b491f5e1407ae680b9a0bc3806dc56827ec85f93c57390491e732","impliedFormat":1},{"version":"acd8fd5090ac73902278889c38336ff3f48af6ba03aa665eb34a75e7ba1dccc4","impliedFormat":1},{"version":"d6258883868fb2680d2ca96bc8b1352cab69874581493e6d52680c5ffecdb6cc","impliedFormat":1},{"version":"1b61d259de5350f8b1e5db06290d31eaebebc6baafd5f79d314b5af9256d7153","impliedFormat":1},{"version":"f258e3960f324a956fc76a3d3d9e964fff2244ff5859dcc6ce5951e5413ca826","impliedFormat":1},{"version":"643f7232d07bf75e15bd8f658f664d6183a0efaca5eb84b48201c7671a266979","impliedFormat":1},{"version":"0f6666b58e9276ac3a38fdc80993d19208442d6027ab885580d93aec76b4ef00","impliedFormat":1},{"version":"05fd364b8ef02fb1e174fbac8b825bdb1e5a36a016997c8e421f5fab0a6da0a0","impliedFormat":1},{"version":"631eff75b0e35d1b1b31081d55209abc43e16b49426546ab5a9b40bdd40b1f60","impliedFormat":1},{"version":"70521b6ab0dcba37539e5303104f29b721bfb2940b2776da4cc818c07e1fefc1","affectsGlobalScope":true,"impliedFormat":1},{"version":"ab41ef1f2cdafb8df48be20cd969d875602483859dc194e9c97c8a576892c052","affectsGlobalScope":true,"impliedFormat":1},{"version":"d153a11543fd884b596587ccd97aebbeed950b26933ee000f94009f1ab142848","affectsGlobalScope":true,"impliedFormat":1},{"version":"21d819c173c0cf7cc3ce57c3276e77fd9a8a01d35a06ad87158781515c9a438a","impliedFormat":1},{"version":"98cffbf06d6bab333473c70a893770dbe990783904002c4f1a960447b4b53dca","affectsGlobalScope":true,"impliedFormat":1},{"version":"ba481bca06f37d3f2c137ce343c7d5937029b2468f8e26111f3c9d9963d6568d","affectsGlobalScope":true,"impliedFormat":1},{"version":"6d9ef24f9a22a88e3e9b3b3d8c40ab1ddb0853f1bfbd5c843c37800138437b61","affectsGlobalScope":true,"impliedFormat":1},{"version":"1db0b7dca579049ca4193d034d835f6bfe73096c73663e5ef9a0b5779939f3d0","affectsGlobalScope":true,"impliedFormat":1},{"version":"9798340ffb0d067d69b1ae5b32faa17ab31b82466a3fc00d8f2f2df0c8554aaa","affectsGlobalScope":true,"impliedFormat":1},{"version":"f26b11d8d8e4b8028f1c7d618b22274c892e4b0ef5b3678a8ccbad85419aef43","affectsGlobalScope":true,"impliedFormat":1},{"version":"5929864ce17fba74232584d90cb721a89b7ad277220627cc97054ba15a98ea8f","impliedFormat":1},{"version":"763fe0f42b3d79b440a9b6e51e9ba3f3f91352469c1e4b3b67bfa4ff6352f3f4","impliedFormat":1},{"version":"25c8056edf4314820382a5fdb4bb7816999acdcb929c8f75e3f39473b87e85bc","impliedFormat":1},{"version":"c464d66b20788266e5353b48dc4aa6bc0dc4a707276df1e7152ab0c9ae21fad8","impliedFormat":1},{"version":"78d0d27c130d35c60b5e5566c9f1e5be77caf39804636bc1a40133919a949f21","impliedFormat":1},{"version":"c6fd2c5a395f2432786c9cb8deb870b9b0e8ff7e22c029954fabdd692bff6195","impliedFormat":1},{"version":"1d6e127068ea8e104a912e42fc0a110e2aa5a66a356a917a163e8cf9a65e4a75","impliedFormat":1},{"version":"5ded6427296cdf3b9542de4471d2aa8d3983671d4cac0f4bf9c637208d1ced43","impliedFormat":1},{"version":"7f182617db458e98fc18dfb272d40aa2fff3a353c44a89b2c0ccb3937709bfb5","impliedFormat":1},{"version":"cadc8aced301244057c4e7e73fbcae534b0f5b12a37b150d80e5a45aa4bebcbd","impliedFormat":1},{"version":"385aab901643aa54e1c36f5ef3107913b10d1b5bb8cbcd933d4263b80a0d7f20","impliedFormat":1},{"version":"9670d44354bab9d9982eca21945686b5c24a3f893db73c0dae0fd74217a4c219","impliedFormat":1},{"version":"0b8a9268adaf4da35e7fa830c8981cfa22adbbe5b3f6f5ab91f6658899e657a7","impliedFormat":1},{"version":"11396ed8a44c02ab9798b7dca436009f866e8dae3c9c25e8c1fbc396880bf1bb","impliedFormat":1},{"version":"ba7bc87d01492633cb5a0e5da8a4a42a1c86270e7b3d2dea5d156828a84e4882","impliedFormat":1},{"version":"4893a895ea92c85345017a04ed427cbd6a1710453338df26881a6019432febdd","impliedFormat":1},{"version":"c21dc52e277bcfc75fac0436ccb75c204f9e1b3fa5e12729670910639f27343e","impliedFormat":1},{"version":"13f6f39e12b1518c6650bbb220c8985999020fe0f21d818e28f512b7771d00f9","impliedFormat":1},{"version":"9b5369969f6e7175740bf51223112ff209f94ba43ecd3bb09eefff9fd675624a","impliedFormat":1},{"version":"4fe9e626e7164748e8769bbf74b538e09607f07ed17c2f20af8d680ee49fc1da","impliedFormat":1},{"version":"24515859bc0b836719105bb6cc3d68255042a9f02a6022b3187948b204946bd2","impliedFormat":1},{"version":"ea0148f897b45a76544ae179784c95af1bd6721b8610af9ffa467a518a086a43","impliedFormat":1},{"version":"24c6a117721e606c9984335f71711877293a9651e44f59f3d21c1ea0856f9cc9","impliedFormat":1},{"version":"dd3273ead9fbde62a72949c97dbec2247ea08e0c6952e701a483d74ef92d6a17","impliedFormat":1},{"version":"405822be75ad3e4d162e07439bac80c6bcc6dbae1929e179cf467ec0b9ee4e2e","impliedFormat":1},{"version":"0db18c6e78ea846316c012478888f33c11ffadab9efd1cc8bcc12daded7a60b6","impliedFormat":1},{"version":"e61be3f894b41b7baa1fbd6a66893f2579bfad01d208b4ff61daef21493ef0a8","impliedFormat":1},{"version":"bd0532fd6556073727d28da0edfd1736417a3f9f394877b6d5ef6ad88fba1d1a","impliedFormat":1},{"version":"89167d696a849fce5ca508032aabfe901c0868f833a8625d5a9c6e861ef935d2","impliedFormat":1},{"version":"615ba88d0128ed16bf83ef8ccbb6aff05c3ee2db1cc0f89ab50a4939bfc1943f","impliedFormat":1},{"version":"a4d551dbf8746780194d550c88f26cf937caf8d56f102969a110cfaed4b06656","impliedFormat":1},{"version":"8bd86b8e8f6a6aa6c49b71e14c4ffe1211a0e97c80f08d2c8cc98838006e4b88","impliedFormat":1},{"version":"317e63deeb21ac07f3992f5b50cdca8338f10acd4fbb7257ebf56735bf52ab00","impliedFormat":1},{"version":"4732aec92b20fb28c5fe9ad99521fb59974289ed1e45aecb282616202184064f","impliedFormat":1},{"version":"2e85db9e6fd73cfa3d7f28e0ab6b55417ea18931423bd47b409a96e4a169e8e6","impliedFormat":1},{"version":"c46e079fe54c76f95c67fb89081b3e399da2c7d109e7dca8e4b58d83e332e605","impliedFormat":1},{"version":"bf67d53d168abc1298888693338cb82854bdb2e69ef83f8a0092093c2d562107","impliedFormat":1},{"version":"2cbe0621042e2a68c7cbce5dfed3906a1862a16a7d496010636cdbdb91341c0f","affectsGlobalScope":true,"impliedFormat":1},{"version":"e2677634fe27e87348825bb041651e22d50a613e2fdf6a4a3ade971d71bac37e","impliedFormat":1},{"version":"7394959e5a741b185456e1ef5d64599c36c60a323207450991e7a42e08911419","impliedFormat":1},{"version":"8c0bcd6c6b67b4b503c11e91a1fb91522ed585900eab2ab1f61bba7d7caa9d6f","impliedFormat":1},{"version":"8cd19276b6590b3ebbeeb030ac271871b9ed0afc3074ac88a94ed2449174b776","affectsGlobalScope":true,"impliedFormat":1},{"version":"696eb8d28f5949b87d894b26dc97318ef944c794a9a4e4f62360cd1d1958014b","impliedFormat":1},{"version":"3f8fa3061bd7402970b399300880d55257953ee6d3cd408722cb9ac20126460c","impliedFormat":1},{"version":"35ec8b6760fd7138bbf5809b84551e31028fb2ba7b6dc91d95d098bf212ca8b4","affectsGlobalScope":true,"impliedFormat":1},{"version":"5524481e56c48ff486f42926778c0a3cce1cc85dc46683b92b1271865bcf015a","impliedFormat":1},{"version":"68bd56c92c2bd7d2339457eb84d63e7de3bd56a69b25f3576e1568d21a162398","affectsGlobalScope":true,"impliedFormat":1},{"version":"3e93b123f7c2944969d291b35fed2af79a6e9e27fdd5faa99748a51c07c02d28","impliedFormat":1},{"version":"9d19808c8c291a9010a6c788e8532a2da70f811adb431c97520803e0ec649991","impliedFormat":1},{"version":"87aad3dd9752067dc875cfaa466fc44246451c0c560b820796bdd528e29bef40","impliedFormat":1},{"version":"4aacb0dd020eeaef65426153686cc639a78ec2885dc72ad220be1d25f1a439df","impliedFormat":1},{"version":"f0bd7e6d931657b59605c44112eaf8b980ba7f957a5051ed21cb93d978cf2f45","impliedFormat":1},{"version":"8db0ae9cb14d9955b14c214f34dae1b9ef2baee2fe4ce794a4cd3ac2531e3255","affectsGlobalScope":true,"impliedFormat":1},{"version":"15fc6f7512c86810273af28f224251a5a879e4261b4d4c7e532abfbfc3983134","impliedFormat":1},{"version":"58adba1a8ab2d10b54dc1dced4e41f4e7c9772cbbac40939c0dc8ce2cdb1d442","impliedFormat":1},{"version":"2fd4c143eff88dabb57701e6a40e02a4dbc36d5eb1362e7964d32028056a782b","impliedFormat":1},{"version":"714435130b9015fae551788df2a88038471a5a11eb471f27c4ede86552842bc9","impliedFormat":1},{"version":"855cd5f7eb396f5f1ab1bc0f8580339bff77b68a770f84c6b254e319bbfd1ac7","impliedFormat":1},{"version":"5650cf3dace09e7c25d384e3e6b818b938f68f4e8de96f52d9c5a1b3db068e86","impliedFormat":1},{"version":"1354ca5c38bd3fd3836a68e0f7c9f91f172582ba30ab15bb8c075891b91502b7","affectsGlobalScope":true,"impliedFormat":1},{"version":"27fdb0da0daf3b337c5530c5f266efe046a6ceb606e395b346974e4360c36419","impliedFormat":1},{"version":"2d2fcaab481b31a5882065c7951255703ddbe1c0e507af56ea42d79ac3911201","impliedFormat":1},{"version":"afbe24ab0d74694372baa632ecb28bb375be53f3be53f9b07ecd7fc994907de5","impliedFormat":1},{"version":"ca867399f7db82df981d6915bcbb2d81131d7d1ef683bc782b59f71dda59bc85","affectsGlobalScope":true,"impliedFormat":1},{"version":"f1dc4bc37e2476766f29718f5006981009e2c7470ddd538d87be731b8bb24280","affectsGlobalScope":true,"impliedFormat":1},{"version":"9e043a1bc8fbf2a255bccf9bf27e0f1caf916c3b0518ea34aa72357c0afd42ec","impliedFormat":1},{"version":"b4f70ec656a11d570e1a9edce07d118cd58d9760239e2ece99306ee9dfe61d02","impliedFormat":1},{"version":"3bc2f1e2c95c04048212c569ed38e338873f6a8593930cf5a7ef24ffb38fc3b6","impliedFormat":1},{"version":"6e70e9570e98aae2b825b533aa6292b6abd542e8d9f6e9475e88e1d7ba17c866","impliedFormat":1},{"version":"f9d9d753d430ed050dc1bf2667a1bab711ccbb1c1507183d794cc195a5b085cc","impliedFormat":1},{"version":"9eece5e586312581ccd106d4853e861aaaa1a39f8e3ea672b8c3847eedd12f6e","impliedFormat":1},{"version":"47ab634529c5955b6ad793474ae188fce3e6163e3a3fb5edd7e0e48f14435333","impliedFormat":1},{"version":"37ba7b45141a45ce6e80e66f2a96c8a5ab1bcef0fc2d0f56bb58df96ec67e972","impliedFormat":1},{"version":"45650f47bfb376c8a8ed39d4bcda5902ab899a3150029684ee4c10676d9fbaee","impliedFormat":1},{"version":"0225ecb9ed86bdb7a2c7fd01f1556906902929377b44483dc4b83e03b3ef227d","affectsGlobalScope":true,"impliedFormat":1},{"version":"74cf591a0f63db318651e0e04cb55f8791385f86e987a67fd4d2eaab8191f730","impliedFormat":1},{"version":"5eab9b3dc9b34f185417342436ec3f106898da5f4801992d8ff38ab3aff346b5","impliedFormat":1},{"version":"12ed4559eba17cd977aa0db658d25c4047067444b51acfdcbf38470630642b23","affectsGlobalScope":true,"impliedFormat":1},{"version":"f3ffabc95802521e1e4bcba4c88d8615176dc6e09111d920c7a213bdda6e1d65","impliedFormat":1},{"version":"f9ab232778f2842ffd6955f88b1049982fa2ecb764d129ee4893cbc290f41977","impliedFormat":1},{"version":"ae56f65caf3be91108707bd8dfbccc2a57a91feb5daabf7165a06a945545ed26","impliedFormat":1},{"version":"a136d5de521da20f31631a0a96bf712370779d1c05b7015d7019a9b2a0446ca9","impliedFormat":1},{"version":"c3b41e74b9a84b88b1dca61ec39eee25c0dbc8e7d519ba11bb070918cfacf656","affectsGlobalScope":true,"impliedFormat":1},{"version":"4737a9dc24d0e68b734e6cfbcea0c15a2cfafeb493485e27905f7856988c6b29","affectsGlobalScope":true,"impliedFormat":1},{"version":"36d8d3e7506b631c9582c251a2c0b8a28855af3f76719b12b534c6edf952748d","impliedFormat":1},{"version":"1ca69210cc42729e7ca97d3a9ad48f2e9cb0042bada4075b588ae5387debd318","impliedFormat":1},{"version":"f5ebe66baaf7c552cfa59d75f2bfba679f329204847db3cec385acda245e574e","impliedFormat":1},{"version":"ed59add13139f84da271cafd32e2171876b0a0af2f798d0c663e8eeb867732cf","affectsGlobalScope":true,"impliedFormat":1},{"version":"05db535df8bdc30d9116fe754a3473d1b6479afbc14ae8eb18b605c62677d518","impliedFormat":1},{"version":"b1810689b76fd473bd12cc9ee219f8e62f54a7d08019a235d07424afbf074d25","impliedFormat":1},{"version":"24259d3dae14de55d22f8b3d3e96954e5175a925ab6a830dc05a1993d4794eda","impliedFormat":1},{"version":"05069916ab9175271d15f9315a41ab28401561fe0e5f85f295c43538a38bd62e","impliedFormat":1},{"version":"be1cc4d94ea60cbe567bc29ed479d42587bf1e6cba490f123d329976b0fe4ee5","impliedFormat":1},{"version":"42bc0e1a903408137c3df2b06dfd7e402cdab5bbfa5fcfb871b22ebfdb30bd0b","impliedFormat":1},{"version":"9894dafe342b976d251aac58e616ac6df8db91fb9d98934ff9dd103e9e82578f","impliedFormat":1},{"version":"413df52d4ea14472c2fa5bee62f7a40abd1eb49be0b9722ee01ee4e52e63beb2","impliedFormat":1},{"version":"db6d2d9daad8a6d83f281af12ce4355a20b9a3e71b82b9f57cddcca0a8964a96","impliedFormat":1},{"version":"829b9e6028b29e6a8b1c01ddb713efe59da04d857089298fa79acbdb3cfcfdef","impliedFormat":1},{"version":"24f8562308dd8ba6013120557fa7b44950b619610b2c6cb8784c79f11e3c4f90","impliedFormat":1},{"version":"c696aa0753345ae6bdaab0e2d4b2053ee76be5140470860eef7e6cadc9f725a1","impliedFormat":1},{"version":"a86f82d646a739041d6702101afa82dcb935c416dd93cbca7fd754fd0282ce1f","impliedFormat":1},{"version":"ad0d1d75d129b1c80f911be438d6b61bfa8703930a8ff2be2f0e1f8a91841c64","impliedFormat":1},{"version":"ce75b1aebb33d510ff28af960a9221410a3eaf7f18fc5f21f9404075fba77256","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"496bbf339f3838c41f164238543e9fe5f1f10659cb30b68903851618464b98ba","impliedFormat":1},{"version":"5178eb4415a172c287c711dc60a619e110c3fd0b7de01ed0627e51a5336aa09c","impliedFormat":1},{"version":"ca6e5264278b53345bc1ce95f42fb0a8b733a09e3d6479c6ccfca55cdc45038c","impliedFormat":1},{"version":"9e2739b32f741859263fdba0244c194ca8e96da49b430377930b8f721d77c000","impliedFormat":1},{"version":"fb1d8e814a3eeb5101ca13515e0548e112bd1ff3fb358ece535b93e94adf5a3a","impliedFormat":1},{"version":"ffa495b17a5ef1d0399586b590bd281056cee6ce3583e34f39926f8dcc6ecdb5","impliedFormat":1},{"version":"98b18458acb46072947aabeeeab1e410f047e0cacc972943059ca5500b0a5e95","impliedFormat":1},{"version":"361e2b13c6765d7f85bb7600b48fde782b90c7c41105b7dab1f6e7871071ba20","impliedFormat":1},{"version":"c86fe861cf1b4c46a0fb7d74dffe596cf679a2e5e8b1456881313170f092e3fa","impliedFormat":1},{"version":"b6db56e4903e9c32e533b78ac85522de734b3d3a8541bf24d256058d464bf04b","impliedFormat":1},{"version":"24daa0366f837d22c94a5c0bad5bf1fd0f6b29e1fae92dc47c3072c3fdb2fbd5","impliedFormat":1},{"version":"570bb5a00836ffad3e4127f6adf581bfc4535737d8ff763a4d6f4cc877e60d98","impliedFormat":1},{"version":"889c00f3d32091841268f0b994beba4dceaa5df7573be12c2c829d7c5fbc232c","impliedFormat":1},{"version":"65f43099ded6073336e697512d9b80f2d4fec3182b7b2316abf712e84104db00","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881","impliedFormat":1},{"version":"acf5a2ac47b59ca07afa9abbd2b31d001bf7448b041927befae2ea5b1951d9f9","impliedFormat":1},{"version":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881","impliedFormat":1},{"version":"d71291eff1e19d8762a908ba947e891af44749f3a2cbc5bd2ec4b72f72ea795f","impliedFormat":1},{"version":"c0480e03db4b816dff2682b347c95f2177699525c54e7e6f6aa8ded890b76be7","impliedFormat":1},{"version":"27ab780875bcbb65e09da7496f2ca36288b0c541abaa75c311450a077d54ec15","impliedFormat":1},{"version":"b620391fe8060cf9bedc176a4d01366e6574d7a71e0ac0ab344a4e76576fcbb8","impliedFormat":1},{"version":"380647d8f3b7f852cca6d154a376dbf8ac620a2f12b936594504a8a852e71d2f","impliedFormat":1},{"version":"208c9af9429dd3c76f5927b971263174aaa4bc7621ddec63f163640cbd3c473c","impliedFormat":1},{"version":"6459054aabb306821a043e02b89d54da508e3a6966601a41e71c166e4ea1474f","impliedFormat":1},{"version":"a23185bc5ef590c287c28a91baf280367b50ae4ea40327366ad01f6f4a8edbc5","impliedFormat":1},{"version":"bb37588926aba35c9283fe8d46ebf4e79ffe976343105f5c6d45f282793352b2","impliedFormat":1},{"version":"002eae065e6960458bda3cf695e578b0d1e2785523476f8a9170b103c709cd4f","impliedFormat":1},{"version":"c83bb0c9c5645a46c68356c2f73fdc9de339ce77f7f45a954f560c7e0b8d5ebb","impliedFormat":1},{"version":"05c97cddbaf99978f83d96de2d8af86aded9332592f08ce4a284d72d0952c391","impliedFormat":1},{"version":"72179f9dd22a86deaad4cc3490eb0fe69ee084d503b686985965654013f1391b","impliedFormat":1},{"version":"2e6114a7dd6feeef85b2c80120fdbfb59a5529c0dcc5bfa8447b6996c97a69f5","impliedFormat":1},{"version":"7b6ff760c8a240b40dab6e4419b989f06a5b782f4710d2967e67c695ef3e93c4","impliedFormat":1},{"version":"c8f004e6036aa1c764ad4ec543cf89a5c1893a9535c80ef3f2b653e370de45e6","impliedFormat":1},{"version":"dd80b1e600d00f5c6a6ba23f455b84a7db121219e68f89f10552c54ba46e4dc9","impliedFormat":1},{"version":"b064c36f35de7387d71c599bfcf28875849a1dbc733e82bd26cae3d1cd060521","impliedFormat":1},{"version":"6a148329edecbda07c21098639ef4254ef7869fb25a69f58e5d6a8b7b69d4236","impliedFormat":1},{"version":"8de9fe97fa9e00ec00666fa77ab6e91b35d25af8ca75dabcb01e14ad3299b150","impliedFormat":1},{"version":"f63ab283a1c8f5c79fabe7ca4ef85f9633339c4f0e822fce6a767f9d59282af2","impliedFormat":1},{"version":"dba114fb6a32b355a9cfc26ca2276834d72fe0e94cd2c3494005547025015369","impliedFormat":1},{"version":"a54c996c8870ef1728a2c1fa9b8eaec0bf4a8001cd2583c02dd5869289465b10","impliedFormat":1},{"version":"3e7efde639c6a6c3edb9847b3f61e308bf7a69685b92f665048c45132f51c218","impliedFormat":1},{"version":"df45ca1176e6ac211eae7ddf51336dc075c5314bc5c253651bae639defd5eec5","impliedFormat":1},{"version":"3754982006a3b32c502cff0867ca83584f7a43b1035989ca73603f400de13c96","impliedFormat":1},{"version":"a30ae9bb8a8fa7b90f24b8a0496702063ae4fe75deb27da731ed4a03b2eb6631","impliedFormat":1},{"version":"f974e4a06953682a2c15d5bd5114c0284d5abf8bc0fe4da25cb9159427b70072","impliedFormat":1},{"version":"50256e9c31318487f3752b7ac12ff365c8949953e04568009c8705db802776fb","impliedFormat":1},{"version":"7d73b24e7bf31dfb8a931ca6c4245f6bb0814dfae17e4b60c9e194a631fe5f7b","impliedFormat":1},{"version":"413586add0cfe7369b64979d4ec2ed56c3f771c0667fbde1bf1f10063ede0b08","impliedFormat":1},{"version":"06472528e998d152375ad3bd8ebcb69ff4694fd8d2effaf60a9d9f25a37a097a","impliedFormat":1},{"version":"50b5bc34ce6b12eccb76214b51aadfa56572aa6cc79c2b9455cdbb3d6c76af1d","impliedFormat":1},{"version":"b7e16ef7f646a50991119b205794ebfd3a4d8f8e0f314981ebbe991639023d0e","impliedFormat":1},{"version":"42c169fb8c2d42f4f668c624a9a11e719d5d07dacbebb63cbcf7ef365b0a75b3","impliedFormat":1},{"version":"a401617604fa1f6ce437b81689563dfdc377069e4c58465dbd8d16069aede0a5","impliedFormat":1},{"version":"e9dd71cf12123419c60dab867d44fbee5c358169f99529121eaef277f5c83531","impliedFormat":1},{"version":"5b6a189ba3a0befa1f5d9cb028eb9eec2af2089c32f04ff50e2411f63d70f25d","impliedFormat":1},{"version":"d6e73f8010935b7b4c7487b6fb13ea197cc610f0965b759bec03a561ccf8423a","impliedFormat":1},{"version":"174f3864e398f3f33f9a446a4f403d55a892aa55328cf6686135dfaf9e171657","impliedFormat":1},{"version":"824c76aec8d8c7e65769688cbee102238c0ef421ed6686f41b2a7d8e7e78a931","impliedFormat":1},{"version":"75b868be3463d5a8cfc0d9396f0a3d973b8c297401d00bfb008a42ab16643f13","impliedFormat":1},{"version":"15a234e5031b19c48a69ccc1607522d6e4b50f57d308ecb7fe863d44cd9f9eb3","impliedFormat":1},{"version":"d682336018141807fb602709e2d95a192828fcb8d5ba06dda3833a8ea98f69e3","impliedFormat":1},{"version":"6124e973eab8c52cabf3c07575204efc1784aca6b0a30c79eb85fe240a857efa","impliedFormat":1},{"version":"0d891735a21edc75df51f3eb995e18149e119d1ce22fd40db2b260c5960b914e","impliedFormat":1},{"version":"3b414b99a73171e1c4b7b7714e26b87d6c5cb03d200352da5342ab4088a54c85","impliedFormat":1},{"version":"4fbd3116e00ed3a6410499924b6403cc9367fdca303e34838129b328058ede40","impliedFormat":1},{"version":"b01bd582a6e41457bc56e6f0f9de4cb17f33f5f3843a7cf8210ac9c18472fb0f","impliedFormat":1},{"version":"0a437ae178f999b46b6153d79095b60c42c996bc0458c04955f1c996dc68b971","impliedFormat":1},{"version":"74b2a5e5197bd0f2e0077a1ea7c07455bbea67b87b0869d9786d55104006784f","impliedFormat":1},{"version":"4a7baeb6325920044f66c0f8e5e6f1f52e06e6d87588d837bdf44feb6f35c664","impliedFormat":1},{"version":"6dcf60530c25194a9ee0962230e874ff29d34c59605d8e069a49928759a17e0a","impliedFormat":1},{"version":"7274fbffbd7c9589d8d0ffba68157237afd5cecff1e99881ea3399127e60572f","impliedFormat":1},{"version":"1a42d2ec31a1fe62fdc51591768695ed4a2dc64c01be113e7ff22890bebb5e3f","impliedFormat":1},{"version":"1a82deef4c1d39f6882f28d275cad4c01f907b9b39be9cbc472fcf2cf051e05b","impliedFormat":1},{"version":"c5426dbfc1cf90532f66965a7aa8c1136a78d4d0f96d8180ecbfc11d7722f1a5","impliedFormat":1},{"version":"65a15fc47900787c0bd18b603afb98d33ede930bed1798fc984d5ebb78b26cf9","impliedFormat":1},{"version":"9d202701f6e0744adb6314d03d2eb8fc994798fc83d91b691b75b07626a69801","impliedFormat":1},{"version":"de9d2df7663e64e3a91bf495f315a7577e23ba088f2949d5ce9ec96f44fba37d","impliedFormat":1},{"version":"c7af78a2ea7cb1cd009cfb5bdb48cd0b03dad3b54f6da7aab615c2e9e9d570c5","impliedFormat":1},{"version":"1ee45496b5f8bdee6f7abc233355898e5bf9bd51255db65f5ff7ede617ca0027","impliedFormat":1},{"version":"0c7c947ff881c4274c0800deaa0086971e0bfe51f89a33bd3048eaa3792d4876","affectsGlobalScope":true,"impliedFormat":1},{"version":"db01d18853469bcb5601b9fc9826931cc84cc1a1944b33cad76fd6f1e3d8c544","affectsGlobalScope":true,"impliedFormat":1},{"version":"a8f8e6ab2fa07b45251f403548b78eaf2022f3c2254df3dc186cb2671fe4996d","affectsGlobalScope":true,"impliedFormat":1},{"version":"fa6c12a7c0f6b84d512f200690bfc74819e99efae69e4c95c4cd30f6884c526e","impliedFormat":1},{"version":"f1c32f9ce9c497da4dc215c3bc84b722ea02497d35f9134db3bb40a8d918b92b","impliedFormat":1},{"version":"b73c319af2cc3ef8f6421308a250f328836531ea3761823b4cabbd133047aefa","affectsGlobalScope":true,"impliedFormat":1},{"version":"e433b0337b8106909e7953015e8fa3f2d30797cea27141d1c5b135365bb975a6","impliedFormat":1},{"version":"15b36126e0089bfef173ab61329e8286ce74af5e809d8a72edcafd0cc049057f","impliedFormat":1},{"version":"ddff7fc6edbdc5163a09e22bf8df7bef75f75369ebd7ecea95ba55c4386e2441","impliedFormat":1},{"version":"106c6025f1d99fd468fd8bf6e5bda724e11e5905a4076c5d29790b6c3745e50c","impliedFormat":1},{"version":"a57b1802794433adec9ff3fed12aa79d671faed86c49b09e02e1ac41b4f1d33a","impliedFormat":1},{"version":"ad10d4f0517599cdeca7755b930f148804e3e0e5b5a3847adce0f1f71bbccd74","impliedFormat":1},{"version":"1042064ece5bb47d6aba91648fbe0635c17c600ebdf567588b4ca715602f0a9d","impliedFormat":1},{"version":"c49469a5349b3cc1965710b5b0f98ed6c028686aa8450bcb3796728873eb923e","impliedFormat":1},{"version":"4a889f2c763edb4d55cb624257272ac10d04a1cad2ed2948b10ed4a7fda2a428","impliedFormat":1},{"version":"7bb79aa2fead87d9d56294ef71e056487e848d7b550c9a367523ee5416c44cfa","impliedFormat":1},{"version":"72d63643a657c02d3e51cd99a08b47c9b020a565c55f246907050d3c8a5e77fb","impliedFormat":1},{"version":"1d415445ea58f8033ba199703e55ff7483c52ac6742075b803bd3e7bbe9f5d61","impliedFormat":1},{"version":"d6406c629bb3efc31aedb2de809bef471e475c86c7e67f3ef9b676b5d7e0d6b2","impliedFormat":1},{"version":"27ff4196654e6373c9af16b6165120e2dd2169f9ad6abb5c935af5abd8c7938c","impliedFormat":1},{"version":"24428762d0c97b44c4784d28eee9556547167c4592d20d542a79243f7ca6a73f","impliedFormat":1},{"version":"8c030e515014c10a2b98f9f48408e3ba18023dfd3f56e3312c6c2f3ae1f55a16","impliedFormat":1},{"version":"dafc31e9e8751f437122eb8582b93d477e002839864410ff782504a12f2a550c","impliedFormat":1},{"version":"754498c5208ce3c5134f6eabd49b25cf5e1a042373515718953581636491f3c3","impliedFormat":1},{"version":"9c82171d836c47486074e4ca8e059735bf97b205e70b196535b5efd40cbe1bc5","impliedFormat":1},{"version":"f56bdc6884648806d34bc66d31cdb787c4718d04105ce2cd88535db214631f82","impliedFormat":1},{"version":"633d58a237f4bb25ec7d565e4ffa32cecdcee8660ac12189c4351c52557cee9e","impliedFormat":1},{"version":"2e4f37ffe8862b14d8e24ae8763daaa8340c0df0b859d9a9733def0eee7562d9","impliedFormat":1},{"version":"13283350547389802aa35d9f2188effaeac805499169a06ef5cd77ce2a0bd63f","impliedFormat":1},{"version":"ce791f6ea807560f08065d1af6014581eeb54a05abd73294777a281b6dfd73c2","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"49f95e989b4632c6c2a578cc0078ee19a5831832d79cc59abecf5160ea71abad","impliedFormat":1},{"version":"9666533332f26e8995e4d6fe472bdeec9f15d405693723e6497bf94120c566c8","impliedFormat":1},{"version":"ce0df82a9ae6f914ba08409d4d883983cc08e6d59eb2df02d8e4d68309e7848b","impliedFormat":1},{"version":"796273b2edc72e78a04e86d7c58ae94d370ab93a0ddf40b1aa85a37a1c29ecd7","impliedFormat":1},{"version":"5df15a69187d737d6d8d066e189ae4f97e41f4d53712a46b2710ff9f8563ec9f","impliedFormat":1},{"version":"e17cd049a1448de4944800399daa4a64c5db8657cc9be7ef46be66e2a2cd0e7c","impliedFormat":1},{"version":"43fa6ea8714e18adc312b30450b13562949ba2f205a1972a459180fa54471018","impliedFormat":1},{"version":"6e89c2c177347d90916bad67714d0fb473f7e37fb3ce912f4ed521fe2892cd0d","impliedFormat":1},{"version":"43ba4f2fa8c698f5c304d21a3ef596741e8e85a810b7c1f9b692653791d8d97a","impliedFormat":1},{"version":"4d4927cbee21750904af7acf940c5e3c491b4d5ebc676530211e389dd375607a","impliedFormat":1},{"version":"72105519d0390262cf0abe84cf41c926ade0ff475d35eb21307b2f94de985778","impliedFormat":1},{"version":"8a97e578a9bc40eb4f1b0ca78f476f2e9154ecbbfd5567ee72943bab37fc156a","impliedFormat":1},{"version":"c857e0aae3f5f444abd791ec81206020fbcc1223e187316677e026d1c1d6fe08","impliedFormat":1},{"version":"ccf6dd45b708fb74ba9ed0f2478d4eb9195c9dfef0ff83a6092fa3cf2ff53b4f","impliedFormat":1},{"version":"2d7db1d73456e8c5075387d4240c29a2a900847f9c1bff106a2e490da8fbd457","impliedFormat":1},{"version":"2b15c805f48e4e970f8ec0b1915f22d13ca6212375e8987663e2ef5f0205e832","impliedFormat":1},{"version":"f22d05663d873ee7a600faf78abb67f3f719d32266803440cf11d5db7ac0cab2","impliedFormat":1},{"version":"d93c544ad20197b3976b0716c6d5cd5994e71165985d31dcab6e1f77feb4b8f2","impliedFormat":1},{"version":"35069c2c417bd7443ae7c7cafd1de02f665bf015479fec998985ffbbf500628c","impliedFormat":1},{"version":"a8b1c79a833ee148251e88a2553d02ce1641d71d2921cce28e79678f3d8b96aa","impliedFormat":1},{"version":"126d4f950d2bba0bd45b3a86c76554d4126c16339e257e6d2fabf8b6bf1ce00c","impliedFormat":1},{"version":"7e0b7f91c5ab6e33f511efc640d36e6f933510b11be24f98836a20a2dc914c2d","impliedFormat":1},{"version":"045b752f44bf9bbdcaffd882424ab0e15cb8d11fa94e1448942e338c8ef19fba","impliedFormat":1},{"version":"2894c56cad581928bb37607810af011764a2f511f575d28c9f4af0f2ef02d1ab","impliedFormat":1},{"version":"0a72186f94215d020cb386f7dca81d7495ab6c17066eb07d0f44a5bf33c1b21a","impliedFormat":1},{"version":"2d3cc2211f352f46ea6b7cf2c751c141ffcdf514d6e7ae7ee20b7b6742da313f","impliedFormat":1},{"version":"c75445151ff8b77d9923191efed7203985b1a9e09eccf4b054e7be864e27923d","impliedFormat":1},{"version":"0aedb02516baf3e66b2c1db9fef50666d6ed257edac0f866ea32f1aa05aa474f","impliedFormat":1},{"version":"fa8a8fbf91ee2a4779496225f0312aac6635b0f21aa09cdafa4283fe32d519c5","affectsGlobalScope":true,"impliedFormat":1},{"version":"0e8aef93d79b000deb6ec336b5645c87de167168e184e84521886f9ecc69a4b5","impliedFormat":1},{"version":"56ccb49443bfb72e5952f7012f0de1a8679f9f75fc93a5c1ac0bafb28725fc5f","impliedFormat":1},{"version":"20fa37b636fdcc1746ea0738f733d0aed17890d1cd7cb1b2f37010222c23f13e","impliedFormat":1},{"version":"d90b9f1520366d713a73bd30c5a9eb0040d0fb6076aff370796bc776fd705943","impliedFormat":1},{"version":"88e9caa9c5d2ba629240b5913842e7c57c5c0315383b8dc9d436ef2b60f1c391","impliedFormat":1},{"version":"19df3488557c2fc9b4d8f0bac0fd20fb59aa19dec67c81f93813951a81a867f8","affectsGlobalScope":true,"impliedFormat":1},{"version":"a15cf91ab29d3667801562a95730c5f0d96e1d87dffa00a8a91da0002e89fd2d","affectsGlobalScope":true,"impliedFormat":1},{"version":"bef86adb77316505c6b471da1d9b8c9e428867c2566270e8894d4d773a1c4dc2","impliedFormat":1},{"version":"de7052bfee2981443498239a90c04ea5cc07065d5b9bb61b12cb6c84313ad4ef","impliedFormat":1},{"version":"a3e7d932dc9c09daa99141a8e4800fc6c58c625af0d4bbb017773dc36da75426","impliedFormat":1},{"version":"43e96a3d5d1411ab40ba2f61d6a3192e58177bcf3b133a80ad2a16591611726d","impliedFormat":1},{"version":"4a2edd238d9104eac35b60d727f1123de5062f452b70ed8e0366cb36387dfdfd","impliedFormat":1},{"version":"ca921bf56756cb6fe957f6af693a35251b134fb932dc13f3dfff0bb7106f80b4","impliedFormat":1},{"version":"fee92c97f1aa59eb7098a0cc34ff4df7e6b11bae71526aca84359a2575f313d8","impliedFormat":1},{"version":"0bd0297484aacea217d0b76e55452862da3c5d9e33b24430e0719d1161657225","impliedFormat":1},{"version":"2ab6d334bcbf2aff3acfc4fd8c73ecd82b981d3c3aa47b3f3b89281772286904","impliedFormat":1},{"version":"d07cbc787a997d83f7bde3877fec5fb5b12ce8c1b7047eb792996ed9726b4dde","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"4805f6161c2c8cefb8d3b8bd96a080c0fe8dbc9315f6ad2e53238f9a79e528a6","impliedFormat":1},{"version":"b83cb14474fa60c5f3ec660146b97d122f0735627f80d82dd03e8caa39b4388c","impliedFormat":1},{"version":"f374cb24e93e7798c4d9e83ff872fa52d2cdb36306392b840a6ddf46cb925cb6","impliedFormat":1},{"version":"49179c6a23701c642bd99abe30d996919748014848b738d8e85181fc159685ff","impliedFormat":1},{"version":"b73cbf0a72c8800cf8f96a9acfe94f3ad32ca71342a8908b8ae484d61113f647","impliedFormat":1},{"version":"bae6dd176832f6423966647382c0d7ba9e63f8c167522f09a982f086cd4e8b23","impliedFormat":1},{"version":"20865ac316b8893c1a0cc383ccfc1801443fbcc2a7255be166cf90d03fac88c9","impliedFormat":1},{"version":"c9958eb32126a3843deedda8c22fb97024aa5d6dd588b90af2d7f2bfac540f23","impliedFormat":1},{"version":"461d0ad8ae5f2ff981778af912ba71b37a8426a33301daa00f21c6ccb27f8156","impliedFormat":1},{"version":"e927c2c13c4eaf0a7f17e6022eee8519eb29ef42c4c13a31e81a611ab8c95577","impliedFormat":1},{"version":"fcafff163ca5e66d3b87126e756e1b6dfa8c526aa9cd2a2b0a9da837d81bbd72","impliedFormat":1},{"version":"70246ad95ad8a22bdfe806cb5d383a26c0c6e58e7207ab9c431f1cb175aca657","impliedFormat":1},{"version":"f00f3aa5d64ff46e600648b55a79dcd1333458f7a10da2ed594d9f0a44b76d0b","impliedFormat":1},{"version":"772d8d5eb158b6c92412c03228bd9902ccb1457d7a705b8129814a5d1a6308fc","impliedFormat":1},{"version":"45490817629431853543adcb91c0673c25af52a456479588b6486daba34f68bb","impliedFormat":1},{"version":"802e797bcab5663b2c9f63f51bdf67eff7c41bc64c0fd65e6da3e7941359e2f7","impliedFormat":1},{"version":"8b4327413e5af38cd8cb97c59f48c3c866015d5d642f28518e3a891c469f240e","impliedFormat":1},{"version":"8514c62ce38e58457d967e9e73f128eedc1378115f712b9eef7127f7c88f82ae","impliedFormat":1},{"version":"f1289e05358c546a5b664fbb35a27738954ec2cc6eb4137350353099d154fc62","impliedFormat":1},{"version":"4b20fcf10a5413680e39f5666464859fc56b1003e7dfe2405ced82371ebd49b6","impliedFormat":1},{"version":"1d17ba45cfbe77a9c7e0df92f7d95f3eefd49ee23d1104d0548b215be56945ad","impliedFormat":1},{"version":"f7d628893c9fa52ba3ab01bcb5e79191636c4331ee5667ecc6373cbccff8ae12","impliedFormat":1},{"version":"5b2323ca2d1bd97e1f32f09452908e015b012e0e4f958f649cbe0c8989a3fb4f","impliedFormat":1},{"version":"9f5a0f3ed33e363b7393223ba4f4af15c13ce94fe3dbdaa476afd2437553a7dd","impliedFormat":1},{"version":"46273e8c29816125d0d0b56ce9a849cc77f60f9a5ba627447501d214466f0ff3","impliedFormat":1},{"version":"d663134457d8d669ae0df34eabd57028bddc04fc444c4bc04bc5215afc91e1f4","impliedFormat":1},{"version":"985153f0deb9b4391110331a2f0c114019dbea90cba5ca68a4107700796e0d75","impliedFormat":1},{"version":"3af3584f79c57853028ef9421ec172539e1fe01853296dc05a9d615ade4ffaf6","impliedFormat":1},{"version":"f82579d87701d639ff4e3930a9b24f4ee13ca74221a9a3a792feb47f01881a9c","impliedFormat":1},{"version":"d7e5d5245a8ba34a274717d085174b2c9827722778129b0081fefd341cca8f55","impliedFormat":1},{"version":"d9d32f94056181c31f553b32ce41d0ef75004912e27450738d57efcd2409c324","impliedFormat":1},{"version":"752513f35f6cff294ffe02d6027c41373adf7bfa35e593dbfd53d95c203635ee","impliedFormat":1},{"version":"6c800b281b9e89e69165fd11536195488de3ff53004e55905e6c0059a2d8591e","impliedFormat":1},{"version":"7d4254b4c6c67a29d5e7f65e67d72540480ac2cfb041ca484847f5ae70480b62","impliedFormat":1},{"version":"1a7e2ea171726446850ec72f4d1525d547ff7e86724cc9e7eec509725752a758","impliedFormat":1},{"version":"8c901126d73f09ecdea4785e9a187d1ac4e793e07da308009db04a7283ec2f37","impliedFormat":1},{"version":"db97922b767bd2675fdfa71e08b49c38b7d2c847a1cc4a7274cb77be23b026f1","impliedFormat":1},{"version":"aab290b8e4b7c399f2c09b957666fc95335eb4522b2dd9ead1bf0cb64da6d6ee","impliedFormat":1},{"version":"94fe3281392e1015b22f39535878610b4fa6f1388dc8d78746be3bc4e4bb8950","impliedFormat":1},{"version":"2652448ac55a2010a1f71dd141f828b682298d39728f9871e1cdf8696ef443fd","impliedFormat":1},{"version":"06c25ddfc2242bd06c19f66c9eae4c46d937349a267810f89783680a1d7b5259","impliedFormat":1},{"version":"120599fd965257b1f4d0ff794bc696162832d9d8467224f4665f713a3119078b","impliedFormat":1},{"version":"5433f33b0a20300cca35d2f229a7fc20b0e8477c44be2affeb21cb464af60c76","impliedFormat":1},{"version":"db036c56f79186da50af66511d37d9fe77fa6793381927292d17f81f787bb195","impliedFormat":1},{"version":"bd4131091b773973ca5d2326c60b789ab1f5e02d8843b3587effe6e1ea7c9d86","impliedFormat":1},{"version":"c7f6485931085bf010fbaf46880a9b9ec1a285ad9dc8c695a9e936f5a48f34b4","impliedFormat":1},{"version":"14f6b927888a1112d662877a5966b05ac1bf7ed25d6c84386db4c23c95a5363b","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"0427df5c06fafc5fe126d14b9becd24160a288deff40e838bfbd92a35f8d0d00","impliedFormat":1},{"version":"90c54a02432d04e4246c87736e53a6a83084357acfeeba7a489c5422b22f5c7a","impliedFormat":1},{"version":"49c346823ba6d4b12278c12c977fb3a31c06b9ca719015978cb145eb86da1c61","impliedFormat":1},{"version":"bfac6e50eaa7e73bb66b7e052c38fdc8ccfc8dbde2777648642af33cf349f7f1","impliedFormat":1},{"version":"92f7c1a4da7fbfd67a2228d1687d5c2e1faa0ba865a94d3550a3941d7527a45d","impliedFormat":1},{"version":"f53b120213a9289d9a26f5af90c4c686dd71d91487a0aa5451a38366c70dc64b","impliedFormat":1},{"version":"83fe880c090afe485a5c02262c0b7cdd76a299a50c48d9bde02be8e908fb4ae6","impliedFormat":1},{"version":"0a372c2d12a259da78e21b25974d2878502f14d89c6d16b97bd9c5017ab1bc12","impliedFormat":1},{"version":"57d67b72e06059adc5e9454de26bbfe567d412b962a501d263c75c2db430f40e","impliedFormat":1},{"version":"6511e4503cf74c469c60aafd6589e4d14d5eb0a25f9bf043dcbecdf65f261972","impliedFormat":1},{"version":"ec1ca97598eda26b7a5e6c8053623acbd88e43be7c4d29c77ccd57abc4c43999","impliedFormat":1},{"version":"6e2261cd9836b2c25eecb13940d92c024ebed7f8efe23c4b084145cd3a13b8a6","impliedFormat":1},{"version":"a67b87d0281c97dfc1197ef28dfe397fc2c865ccd41f7e32b53f647184cc7307","impliedFormat":1},{"version":"771ffb773f1ddd562492a6b9aaca648192ac3f056f0e1d997678ff97dbb6bf9b","impliedFormat":1},{"version":"232f70c0cf2b432f3a6e56a8dc3417103eb162292a9fd376d51a3a9ea5fbbf6f","impliedFormat":1},{"version":"a47e6d954d22dd9ebb802e7e431b560ed7c581e79fb885e44dc92ed4f60d4c07","impliedFormat":1},{"version":"f019e57d2491c159d47a107fd90219a1734bdd2e25cd8d1db3c8fae5c6b414c4","impliedFormat":1},{"version":"8a0e762ceb20c7e72504feef83d709468a70af4abccb304f32d6b9bac1129b2c","impliedFormat":1},{"version":"d1c9bf292a54312888a77bb19dba5e2503ad803f5393beafd45d78d2f4fe9b48","impliedFormat":1},{"version":"9252d498a77517aab5d8d4b5eb9d71e4b225bbc7123df9713e08181de63180f6","impliedFormat":1},{"version":"cb8d8ef7b9ce8ed3e6f1c814fcbf3f90dab0cb8863079236784fc350746e27c4","impliedFormat":1},{"version":"35e6379c3f7cb27b111ad4c1aa69538fd8e788ab737b8ff7596a1b40e96f4f90","impliedFormat":1},{"version":"1fffe726740f9787f15b532e1dc870af3cd964dbe29e191e76121aa3dd8693f2","impliedFormat":1},{"version":"3be035da7bee86b4c3abf392e0edaa44fc6e45092995eefe36b39118c8a84068","affectsGlobalScope":true,"impliedFormat":1},{"version":"8f828825d077c2fa0ea606649faeb122749273a353daab23924fe674e98ba44c","impliedFormat":1},{"version":"2896c2e673a5d3bd9b4246811f79486a073cbb03950c3d252fba10003c57411a","impliedFormat":1},{"version":"616775f16134fa9d01fc677ad3f76e68c051a056c22ab552c64cc281a9686790","impliedFormat":1},{"version":"65c24a8baa2cca1de069a0ba9fba82a173690f52d7e2d0f1f7542d59d5eb4db0","impliedFormat":1},{"version":"f9fe6af238339a0e5f7563acee3178f51db37f32a2e7c09f85273098cee7ec49","impliedFormat":1},{"version":"407a06ba04eede4074eec470ecba2784cbb3bf4e7de56833b097dd90a2aa0651","impliedFormat":1},{"version":"77e71242e71ebf8528c5802993697878f0533db8f2299b4d36aa015bae08a79c","impliedFormat":1},{"version":"98a787be42bd92f8c2a37d7df5f13e5992da0d967fab794adbb7ee18370f9849","impliedFormat":1},{"version":"5c96bad5f78466785cdad664c056e9e2802d5482ca5f862ed19ba34ffbb7b3a4","impliedFormat":1},{"version":"81d8603ac527e75cfec72bb9391228b58f161c2b33514a9d814c7f3ebd3ef466","impliedFormat":1},{"version":"5f3dc10ae646f375776b4e028d2bed039a93eebbba105694d8b910feebbe8b9c","impliedFormat":1},{"version":"bb0cd7862b72f5eba39909c9889d566e198fcaddf7207c16737d0c2246112678","impliedFormat":1},{"version":"4545c1a1ceca170d5d83452dd7c4994644c35cf676a671412601689d9a62da35","impliedFormat":1},{"version":"320f4091e33548b554d2214ce5fc31c96631b513dffa806e2e3a60766c8c49d9","impliedFormat":1},{"version":"a2d648d333cf67b9aeac5d81a1a379d563a8ffa91ddd61c6179f68de724260ff","impliedFormat":1},{"version":"d90d5f524de38889d1e1dbc2aeef00060d779f8688c02766ddb9ca195e4a713d","impliedFormat":1},{"version":"a3f41ed1b4f2fc3049394b945a68ae4fdefd49fa1739c32f149d32c0545d67f5","impliedFormat":1},{"version":"bad68fd0401eb90fe7da408565c8aee9c7a7021c2577aec92fa1382e8876071a","impliedFormat":1},{"version":"47699512e6d8bebf7be488182427189f999affe3addc1c87c882d36b7f2d0b0e","impliedFormat":1},{"version":"fec01479923e169fb52bd4f668dbeef1d7a7ea6e6d491e15617b46f2cacfa37d","impliedFormat":1},{"version":"8a8fb3097ba52f0ae6530ec6ab34e43e316506eb1d9aa29420a4b1e92a81442d","impliedFormat":1},{"version":"44e09c831fefb6fe59b8e65ad8f68a7ecc0e708d152cfcbe7ba6d6080c31c61e","impliedFormat":1},{"version":"1c0a98de1323051010ce5b958ad47bc1c007f7921973123c999300e2b7b0ecc0","impliedFormat":1},{"version":"4655709c9cb3fd6db2b866cab7c418c40ed9533ce8ea4b66b5f17ec2feea46a9","impliedFormat":1},{"version":"87affad8e2243635d3a191fa72ef896842748d812e973b7510a55c6200b3c2a4","impliedFormat":1},{"version":"ad036a85efcd9e5b4f7dd5c1a7362c8478f9a3b6c3554654ca24a29aa850a9c5","impliedFormat":1},{"version":"fedebeae32c5cdd1a85b4e0504a01996e4a8adf3dfa72876920d3dd6e42978e7","impliedFormat":1},{"version":"3eecb25bb467a948c04874d70452b14ae7edb707660aac17dc053e42f2088b00","impliedFormat":1},{"version":"cdf21eee8007e339b1b9945abf4a7b44930b1d695cc528459e68a3adc39a622e","impliedFormat":1},{"version":"330896c1a2b9693edd617be24fbf9e5895d6e18c7955d6c08f028f272b37314d","impliedFormat":1},{"version":"1d9c0a9a6df4e8f29dc84c25c5aa0bb1da5456ebede7a03e03df08bb8b27bae6","impliedFormat":1},{"version":"84380af21da938a567c65ef95aefb5354f676368ee1a1cbb4cae81604a4c7d17","impliedFormat":1},{"version":"1af3e1f2a5d1332e136f8b0b95c0e6c0a02aaabd5092b36b64f3042a03debf28","impliedFormat":1},{"version":"30d8da250766efa99490fc02801047c2c6d72dd0da1bba6581c7e80d1d8842a4","impliedFormat":1},{"version":"03566202f5553bd2d9de22dfab0c61aa163cabb64f0223c08431fb3fc8f70280","impliedFormat":1},{"version":"5f0292a40df210ab94b9fb44c8b775c51e96777e14e073900e392b295ca1061b","impliedFormat":1},{"version":"bc9ee0192f056b3d5527bcd78dc3f9e527a9ba2bdc0a2c296fbc9027147df4b2","impliedFormat":1},{"version":"8627ad129bcf56e82adff0ab5951627c993937aa99f5949c33240d690088b803","impliedFormat":1},{"version":"1de80059b8078ea5749941c9f863aa970b4735bdbb003be4925c853a8b6b4450","impliedFormat":1},{"version":"1d079c37fa53e3c21ed3fa214a27507bda9991f2a41458705b19ed8c2b61173d","impliedFormat":1},{"version":"5bf5c7a44e779790d1eb54c234b668b15e34affa95e78eada73e5757f61ed76a","impliedFormat":1},{"version":"5835a6e0d7cd2738e56b671af0e561e7c1b4fb77751383672f4b009f4e161d70","impliedFormat":1},{"version":"5c634644d45a1b6bc7b05e71e05e52ec04f3d73d9ac85d5927f647a5f965181a","impliedFormat":1},{"version":"4b7f74b772140395e7af67c4841be1ab867c11b3b82a51b1aeb692822b76c872","impliedFormat":1},{"version":"27be6622e2922a1b412eb057faa854831b95db9db5035c3f6d4b677b902ab3b7","impliedFormat":1},{"version":"a68d4b3182e8d776cdede7ac9630c209a7bfbb59191f99a52479151816ef9f9e","impliedFormat":99},{"version":"39644b343e4e3d748344af8182111e3bbc594930fff0170256567e13bbdbebb0","impliedFormat":99},{"version":"ed7fd5160b47b0de3b1571c5c5578e8e7e3314e33ae0b8ea85a895774ee64749","impliedFormat":99},{"version":"63a7595a5015e65262557f883463f934904959da563b4f788306f699411e9bac","impliedFormat":1},{"version":"ecbaf0da125974be39c0aac869e403f72f033a4e7fd0d8cd821a8349b4159628","impliedFormat":1},{"version":"4ba137d6553965703b6b55fd2000b4e07ba365f8caeb0359162ad7247f9707a6","impliedFormat":1},{"version":"ceec3c81b2d81f5e3b855d9367c1d4c664ab5046dff8fd56552df015b7ccbe8f","affectsGlobalScope":true,"impliedFormat":1},{"version":"8fac4a15690b27612d8474fb2fc7cc00388df52d169791b78d1a3645d60b4c8b","affectsGlobalScope":true,"impliedFormat":1},{"version":"064ac1c2ac4b2867c2ceaa74bbdce0cb6a4c16e7c31a6497097159c18f74aa7c","impliedFormat":1},{"version":"3dc14e1ab45e497e5d5e4295271d54ff689aeae00b4277979fdd10fa563540ae","impliedFormat":1},{"version":"1d63055b690a582006435ddd3aa9c03aac16a696fac77ce2ed808f3e5a06efab","impliedFormat":1},{"version":"b789bf89eb19c777ed1e956dbad0925ca795701552d22e68fd130a032008b9f9","impliedFormat":1},"85ae5aee75f011967cf2d25cbc342f62d69314e9d925f7f4aa3456fc2cffcca6",{"version":"d238747e88c8c708451fa6f01ca63893f0396c43d072ec0c7c61f63eaf201789","impliedFormat":99},{"version":"f3d73901e4383f84add3a98573a2738ac5d0cbc648697c302b69b26b75ee140f","impliedFormat":99},{"version":"4acccd722f80edbf731840b8363e17f18f679434a4578ee44f1d3b70c67d858c","impliedFormat":99},{"version":"b3fae73d7dd47d6be5831e14cfa75be9ad8ad5da6ca1f1777bb30be81d744d2b","impliedFormat":99},{"version":"c2ea0cb5e8f8b454f942b3da57e88327cef84016971b28a6b0937475fc815f83","signature":"9c0eeb8de8dfdfb63ebcef09564c84ae1f6b6187c8e8e274fc5b0ee0a2c8432b"},{"version":"b34209befaf07b7cc1932e5cc137ce121cbc9f892551126962d9e908be91adb4","impliedFormat":1},{"version":"32727845ab5bd8a9ef3e4844c567c09f6d418fcf0f90d381c00652a6f23e7f6e","impliedFormat":1},{"version":"2c0b5ace721ddf7314b622bbad664a9958cfd1068422dbed5cdb760cba1c7f0c","impliedFormat":1},{"version":"7a8ec10b0834eb7183e4bfcd929838ac77583828e343211bb73676d1e47f6f01","impliedFormat":1},{"version":"707332817d714a4277d2d386d9c209cdb2137313284c65621849a12f413aaf5e","affectsGlobalScope":true,"impliedFormat":1},{"version":"3f00324f263189b385c3a9383b1f4dae6237697bcf0801f96aa35c340512d79c","impliedFormat":1},{"version":"ec8997c2e5cea26befc76e7bf990750e96babb16977673a9ff3b5c0575d01e48","impliedFormat":1},{"version":"821722285894d0cb2c5f56ec6bbf912b902ccff75255e482237374a2141fa3ad","signature":"c2b8fdddf46a684b2230e08665f6679f3a00186ea2c29a29c6ac9a017c162326"},{"version":"cafc6bda1d830c9df85af7357f6fe5f32d2df862cbdc27a975da591f81ed03e5","signature":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881"},{"version":"03981a348c4473a6a0bbaf606b651043860c8fc3efd7786bc02c4a1e05bf37b1","impliedFormat":99},{"version":"fb82344c312fd920a25c33ae4e0381023f46ef1432775cda1d9ab50077e639a8","impliedFormat":99},{"version":"e0037499acbd201cd60956a4d54ee45e4953cd60f80a2d8acb1bd13c9b134842","impliedFormat":99},{"version":"92339882b71c2ec1f48f82fe70d4ccd003822c4959169f0bab4f1ed0e99dd486","impliedFormat":99},{"version":"d627151917233bf28874a54e2478a6c5e15ef92b7aa8ed0500ca663d1510ce26","impliedFormat":99},{"version":"b83ed62180881087ad8d0bbcaf9c1e18c1bf54c2e7746aa14091334ecf5064f1","signature":"f16c45978bca52f9e6e15e30cb2a644c14a8f12ef7e7883955c0e855a1461639"},{"version":"1506833b09415d814e6904736b77e3cfa9c314d3e8e9608a45402b45cc1d445e","signature":"b5921651dd7f84bf735c77ba7f97a48389e53930d65916f7ac64ae0423c39d81"},{"version":"3f20dbe66f579955935fd0087811cb36ddc84114b894899994f2c540859b645b","signature":"86bd58c9db702e6d85d09d5f2c048e41d1a46879f779e682616e2566ea2db90b"},{"version":"52d0b34f865c3261d992c38f235278e45d1cc5b0706df8a3833bb65c02c539ee","signature":"70b83359a8592fd5bd75c234e3f94f3190a7d16a5d98c543e5fa6fa09a922637"},{"version":"1d4fea28255fec3900e4fa87b50f964dcb2f8c4b57db18fbacb0622fa76a66c3","signature":"d1560f98cd525aba422fab9d0eab88a99d688535f9fe3e9571ad07107150658e"},{"version":"a6a73e063520c9b6f5366304198dd85932f8883a4a6af92b9593a759e4e1c915","signature":"89aad0b689a67c22ccf4d9286189d9100d12392a33cc1e3e4c82e33b0f5532ae"},{"version":"58347b71d621efa402f085188b5eb1d50ed2e5d59a8244d93fef9bc348132696","signature":"52d8766ccab59f3b1886174386c40c467d39ec131d95db874278e5caa0435ff6"},{"version":"dcd039568bf735bef587e81103259821f4075276b00b09b0a953bdd3993382b3","signature":"07b872bf818081b560e585efa3abe6791f40a56e690bedde9cb5e6533bc9dd59"},{"version":"007680c685324a5fd9410f187afb475527f6dbcbee59c59265128bad0378e9a4","signature":"ab4f78ab1262fc757477b389dc41e2059a98fbfc2f126e908ad968e24edf2208"},{"version":"73cd7d6e4cf95533c4773d70a053560ede25412e8dc3fe78899295d2772f5256","signature":"9cf6dcf6fdcc94f8e2883f3b5e55cafe601eff468954d53710503bd1c2877c65"},{"version":"a7d595f18175110b5d8d0fa0d84e7353089073715a2260651fde382c1d937cd5","signature":"43bf088ea02b5e1c3ed20cb3c09f838865b8cf7541483947a7d67d32b92c43fe"},{"version":"825d8bf942dbc5fdd8da71cef6e8f75608e81e19de6176fbeebdbc4ac8a8dd75","signature":"dfd5af6b0313b9befc7d45c6ffa3f928cd0f2dba7b7ebec0b46f6d664d05bb66"},{"version":"c57b441e0c0a9cbdfa7d850dae1f8a387d6f81cbffbc3cd0465d530084c2417d","impliedFormat":99},{"version":"8b15d05f236e8537d3ecbe4422ce46bf0de4e4cd40b2f909c91c5818af4ff17a","impliedFormat":1},{"version":"982bf16c5d13d9ab58c3d3a6485c39fe44f3796f8f5163d880f8818432b22ee0","signature":"512960c0e955a2324b34354dac25e3e4d431a1af4cd33077935eda5e95c8b7e1"},{"version":"4dc481ce5f4588cc7c9c3f7c7bb99407321b774e0e6db995f924f440149b101c","signature":"523cbf15f5b12fdc02dbcf3f59602623f8b49c4cc351678ce8b0106575cdddbf"},{"version":"d1f1e0d62cb8d8d1e04c26e14de842d8a151f75812d81b046c65b5d1fe8e4b27","signature":"512960c0e955a2324b34354dac25e3e4d431a1af4cd33077935eda5e95c8b7e1"},{"version":"5b066e9723a0825f49eb8f3d0cb54fa1afde3870a0237a5a254f4a42a358fb6e","signature":"49df9a46ebdc372b3fa4df4ccc8425c638bd56e72dee2cfff3ea1e97d2c794de"},{"version":"a9373d52584b48809ffd61d74f5b3dfd127da846e3c4ee3c415560386df3994b","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"2c57db2bf2dbd9e8ef4853be7257d62a1cb72845f7b976bb4ee827d362675f96","impliedFormat":99},{"version":"f7aa45a83c6b92541437a989e435bc06234dd42d445831d3ddb9df6e6d444260","impliedFormat":1},{"version":"894eb30992723a15e3ae75c46a3bf8808a526f5b3bff2c61c78f4d3e8d521cb8","signature":"c9e66c79207c3be6fa9cda6bf6f96476f6432d60a67bb823178c5c5bbc1ecb95"},{"version":"a346701ad6dcdaa58e388fe0995fc5304c09c395b8cba68ed872780f8c102004","impliedFormat":99},{"version":"2fbe402f0ee5aa8ab55367f88030f79d46211c0a0f342becaa9f648bf8534e9d","impliedFormat":1},{"version":"b94258ef37e67474ac5522e9c519489a55dcb3d4a8f645e335fc68ea2215fe88","impliedFormat":1},{"version":"d5793bd9966c2082ad4ec484f7e5a699e2a94d732b1ac2b3b3899535f53ae255","signature":"c0a523ae4fc5a14fb42b9e2212b16e13c8c8494ec020cc1e52adc1bf84e7fb05"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"7ec047b73f621c526468517fea779fec2007dd05baa880989def59126c98ef79","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"8dd450de6d756cee0761f277c6dc58b0b5a66b8c274b980949318b8cad26d712","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"6b5f886fe41e2e767168e491fe6048398ed6439d44e006d9f51cc31265f08978","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"56a87e37f91f5625eb7d5f8394904f3f1e2a90fb08f347161dc94f1ae586bdd0","impliedFormat":99},{"version":"6b863463764ae572b9ada405bf77aac37b5e5089a3ab420d0862e4471051393b","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"904d6ad970b6bd825449480488a73d9b98432357ab38cf8d31ffd651ae376ff5","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"1179ef8174e0e4a09d35576199df04803b1db17c0fb35b9326442884bc0b0cce","impliedFormat":99},{"version":"43a882fde54ca685bcb35d77e588846ff3391155e320436b6c271af7f8de1a7d","signature":"d77c731b000c1abdf6097fdc49718bdab8e373595417be6f898c3d83eedaea1e"},{"version":"6b278654c8265f46ba0cff3373e4a339d12f3c0e0cdcd7ce019502194161a6fb","signature":"3d2c0cc03db7d29147810b60ba10df1a5e86ebbd8b1d2782d924f80f212ca534"},{"version":"097735fbb69c93e3552d60d8080983f717b2f92d3f377d4c031dadce78611ad7","signature":"bd4f71826c8189a0e59d664e81a790582c93812ed97a3b9857f02aa3a0d0c4a9"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"68b6a7501a56babd7bcd840e0d638ee7ec582f1e70b3c36ebf32e5e5836913c8","impliedFormat":99},{"version":"7a14bf21ae8a29d64c42173c08f026928daf418bed1b97b37ac4bb2aa197b89b","impliedFormat":99},{"version":"711dbe2de6452fe53027615421afc6f5941533aacc6fb3e9a831635bb0f23ced","signature":"20f5c6fda7d5906e7abca36cb5068de741c18155bbe26f5aca1e1c29ca5e2f42"},{"version":"89041c0832cb85e54623db6931f6887f1eab666d895d58acb9cae843f6c8f317","signature":"cbf221f62f476e7d8744b5371ff3e302e70609d47d28eec8d01def18095a3e6d"},{"version":"1100f3eab8432605642b8cead539c936179c53c905b212b488b295db2bf6e177","signature":"fe4ceb08d9067ccba5e917a320e68f5b6c3e371eeb6cfc352a1035b278585100"},{"version":"aad6e9accea5f152823a1f334386d8772117925d93b0321c188255348e6786c5","signature":"47e9bd2b0b35ac80d8c2e8d479ba18e1c8ade25abb6f719a0fa0cf043071af51"},{"version":"441ad397d63695d036d3bb29b4a3325517d6594bc149f395a4fe6dd0f6414621","signature":"5444793155d4c4d1787892fe2e0834da07e84d46d410943060d4ee2523dd5650"},{"version":"9703848fac4b9cb3a88bff55375c612d3b20d618e831bba6a8a7d6cd135f418a","signature":"d218480e5404383f56129873277eaab3713141d18e5a5a5152b5c811a968fed2"},{"version":"9d3b774857a2faa0c5bff8be5bfeda4f2b10b03fab7ff952dedaea2e7da4b00a","signature":"03013e8ee349125d195f2f2f4e2441f048fa0b2d632c012b5237f13a748a1362"},{"version":"4badb8e0f2fba7a7a55e32d877f93572292b41fb086b2cd2672388c803f00e84","signature":"a77b1deae4fb9f9916400df3926ffc60e1b27657a8c74f1d5f80fb612f63c07f"},{"version":"67668e405c092220c20129866b9cecbf79fc4922156cb22607206598131dd4b5","signature":"495f897ca489e5f8fb1ace34e25fb53103e9800ccd9879374a74a91cae6f5525"},{"version":"85e75abb2b960333554d87b59c2c93837bcdac57fc8f5bec08e3785dfcdbca85","signature":"a013754e9c9372195578014767d9daa25f3a37a2cac34b96228225fbf6ba5c86"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"71acd198e19fa38447a3cbc5c33f2f5a719d933fccf314aaff0e8b0593271324","impliedFormat":99},{"version":"4db2dc92c77cf9107c5413328b05788d20525bc0cd58d92250c8ec40371266a9","signature":"7711adec5eed0b4cb819cae62ea768204c4bd260fa3ee1aceb586358db5f6aa0"},{"version":"0ca6eea0f2aa49492a26004b6a203d76f79422d5cd58f59fd2269e70fea53124","signature":"f7f35a0bed9d64bc9113359bb273c31371cf264204de1350b1e25e0b5a7b9fbc"},{"version":"d57f7587e94e3995d49a4e93ad840d4cdad8d07e3c5f00b9637bef45d4cf479d","signature":"3cde497ee21e616c51b32abde6f51707adf414329cc502a37e9a69013986a24e"},{"version":"84bd710acc51130debaf2f5bcf13025ddb2cb960bfcb44c852076aa3ac0dc239","signature":"77d378c4473baa4ab9b7b6161cfac73e4efb930732e9b5a9cd4b74264b6b7fc6"},{"version":"2cef84bf00cbdb452fdc5d8ecfe7b8c0aa3fa788bdc4ad8961e2e636530dbb60","impliedFormat":99},{"version":"24104650185414f379d5cc35c0e2c19f06684a73de5b472bae79e0d855771ecf","impliedFormat":99},{"version":"799003c0ab928582fca04977f47b8d85b43a8de610f4eef0ad2d069fbb9f9399","impliedFormat":99},{"version":"b13dd41c344a23e085f81b2f5cd96792e6b35ae814f32b25e39d9841844ad240","impliedFormat":99},{"version":"17d8b4e6416e48b6e23b73d05fd2fde407e2af8fddbe9da2a98ede14949c3489","impliedFormat":99},{"version":"6d17b2b41f874ab4369b8e04bdbe660163ea5c8239785c850f767370604959e3","impliedFormat":99},{"version":"04b4c044c8fe6af77b6c196a16c41e0f7d76b285d036d79dcaa6d92e24b4982b","impliedFormat":99},{"version":"30bdeead5293c1ddfaea4097d3e9dd5a6b0bc59a1e07ff4714ea1bbe7c5b2318","impliedFormat":99},{"version":"e7df226dcc1b0ce76b32f160556f3d1550124c894aae2d5f73cefaaf28df7779","impliedFormat":99},{"version":"f2b7eef5c46c61e6e72fba9afd7cc612a08c0c48ed44c3c5518559d8508146a2","impliedFormat":99},{"version":"00f0ba57e829398d10168b7db1e16217f87933e61bd8612b53a894bd7d6371da","impliedFormat":99},{"version":"126b20947d9fa74a88bb4e9281462bda05e529f90e22d08ee9f116a224291e84","impliedFormat":99},{"version":"40d9e43acee39702745eb5c641993978ac40f227475eacc99a83ba893ad995db","impliedFormat":99},{"version":"8a66b69b21c8de9cb88b4b6d12f655d5b7636e692a014c5aa1bd81745c8c51d5","impliedFormat":99},{"version":"ebbb846bdd5a78fdacff59ae04cea7a097912aeb1a2b34f8d88f4ebb84643069","impliedFormat":99},{"version":"7321adb29ffd637acb33ee67ea035f1a97d0aa0b14173291cc2fd58e93296e04","impliedFormat":99},{"version":"320816f1a4211188f07a782bdb6c1a44555b3e716ce13018f528ad7387108d5f","impliedFormat":99},{"version":"b2cc8a474b7657f4a03c67baf6bff75e26635fd4b5850675e8cad524a09ddd0c","impliedFormat":99},{"version":"0d081e9dc251063cc69611041c17d25847e8bdbe18164baaa89b7f1f1633c0ab","impliedFormat":99},{"version":"a64c25d8f4ec16339db49867ea2324e77060782993432a875d6e5e8608b0de1e","impliedFormat":99},{"version":"0739310b6b777f3e2baaf908c0fbc622c71160e6310eb93e0d820d86a52e2e23","impliedFormat":99},{"version":"37b32e4eadd8cd3c263e7ac1681c58b2ac54f3f77bb34c5e4326cc78516d55a9","impliedFormat":99},{"version":"9b7a8974e028c4ed6f7f9abb969e3eb224c069fd7f226e26fcc3a5b0e2a1eba8","impliedFormat":99},{"version":"e8100b569926a5592146ed68a0418109d625a045a94ed878a8c5152b1379237c","impliedFormat":99},{"version":"594201c616c318b7f3149a912abd8d6bdf338d765b7bcbde86bca2e66b144606","impliedFormat":99},{"version":"03e380975e047c5c6ded532cf8589e6cc85abb7be3629e1e4b0c9e703f2fd36f","impliedFormat":99},{"version":"fae14b53b7f52a8eb3274c67c11f261a58530969885599efe3df0277b48909e1","impliedFormat":99},{"version":"c41206757c428186f2e0d1fd373915c823504c249336bdc9a9c9bbdf9da95fef","impliedFormat":99},{"version":"e961f853b7b0111c42b763a6aa46fc70d06a697db3d8ed69b38f7ba0ae42a62b","impliedFormat":99},{"version":"3db90f79e36bcb60b3f8de1bc60321026800979c150e5615047d598c787a64b7","impliedFormat":99},{"version":"639b6fb3afbb8f6067c1564af2bd284c3e883f0f1556d59bd5eb87cdbbdd8486","impliedFormat":99},{"version":"49795f5478cb607fd5965aa337135a8e7fd1c58bc40c0b6db726adf186dd403f","impliedFormat":99},{"version":"7d8890e6e2e4e215959e71d5b5bd49482cf7a23be68d48ea446601a4c99bd511","impliedFormat":99},{"version":"d56f72c4bb518de5702b8b6ae3d3c3045c99e0fd48b3d3b54c653693a8378017","impliedFormat":99},{"version":"4c9ac40163e4265b5750510d6d2933fb7b39023eed69f7b7c68b540ad960826e","impliedFormat":99},{"version":"8dfab17cf48e7be6e023c438a9cdf6d15a9b4d2fa976c26e223ba40c53eb8da8","impliedFormat":99},{"version":"38bdf7ccacfd8e418de3a7b1e3cecc29b5625f90abc2fa4ac7843a290f3bf555","impliedFormat":99},{"version":"9819e46a914735211fbc04b8dc6ba65152c62e3a329ca0601a46ba6e05b2c897","impliedFormat":99},{"version":"50f0dc9a42931fb5d65cdd64ba0f7b378aedd36e0cfca988aa4109aad5e714cb","impliedFormat":99},{"version":"894f23066f9fafccc6e2dd006ed5bd85f3b913de90f17cf1fe15a2eb677fd603","impliedFormat":99},{"version":"abdf39173867e6c2d6045f120a316de451bbb6351a6929546b8470ddf2e4b3b9","impliedFormat":99},{"version":"aa2cb4053f948fbd606228195bbe44d78733861b6f7204558bbee603202ee440","impliedFormat":99},{"version":"6911b41bfe9942ac59c2da1bbcbe5c3c1f4e510bf65cae89ed00f434cc588860","impliedFormat":99},{"version":"7b81bc4d4e2c764e85d869a8dd9fe3652b34b45c065482ac94ffaacc642b2507","impliedFormat":99},{"version":"895df4edb46ccdcbce2ec982f5eed292cf7ea3f7168f1efea738ee346feab273","impliedFormat":99},{"version":"8692bb1a4799eda7b2e3288a6646519d4cebb9a0bddf800085fc1bd8076997a0","impliedFormat":99},{"version":"239c9e98547fe99711b01a0293f8a1a776fc10330094aa261f3970aaba957c82","impliedFormat":99},{"version":"34833ec50360a32efdc12780ae624e9a710dd1fd7013b58c540abf856b54285a","impliedFormat":99},{"version":"647538e4007dcc351a8882067310a0835b5bb8559d1cfa5f378e929bceb2e64d","impliedFormat":99},{"version":"992d6b1abcc9b6092e5a574d51d441238566b6461ade5de53cb9718e4f27da46","impliedFormat":99},{"version":"938702305649bf1050bd79f3803cf5cc2904596fc1edd4e3b91033184eae5c54","impliedFormat":99},{"version":"1e931d3c367d4b96fe043e792196d9c2cf74f672ff9c0b894be54e000280a79d","impliedFormat":99},{"version":"05bec322ea9f6eb9efcd6458bb47087e55bd688afdd232b78379eb5d526816ed","impliedFormat":99},{"version":"4c449a874c2d2e5e5bc508e6aa98f3140218e78c585597a21a508a647acd780a","impliedFormat":99},{"version":"dae15e326140a633d7693e92b1af63274f7295ea94fb7c322d5cbe3f5e48be88","impliedFormat":99},{"version":"c2b0a869713bca307e58d81d1d1f4b99ebfc7ec8b8f17e80dde40739aa8a2bc6","impliedFormat":99},{"version":"6e4b4ff6c7c54fa9c6022e88f2f3e675eac3c6923143eb8b9139150f09074049","impliedFormat":99},{"version":"69559172a9a97bbe34a32bff8c24ef1d8c8063feb5f16a6d3407833b7ee504cf","impliedFormat":99},{"version":"86b94a2a3edcb78d9bfcdb3b382547d47cb017e71abe770c9ee8721e9c84857f","impliedFormat":99},{"version":"e3fafafda82853c45c0afc075fea1eaf0df373a06daf6e6c7f382f9f61b2deb3","impliedFormat":99},{"version":"a4ba4b31de9e9140bc49c0addddbfaf96b943a7956a46d45f894822e12bf5560","impliedFormat":99},{"version":"d8a7926fc75f2ed887f17bae732ee31a4064b8a95a406c87e430c58578ee1f67","impliedFormat":99},{"version":"9886ffbb134b0a0059fd82219eba2a75f8af341d98bc6331b6ef8a921e10ec68","impliedFormat":99},{"version":"c2ead057b70d0ae7b87a771461a6222ebdb187ba6f300c974768b0ae5966d10e","impliedFormat":99},{"version":"46687d985aed8485ab2c71085f82fafb11e69e82e8552cf5d3849c00e64a00a5","impliedFormat":99},{"version":"999ca66d4b5e2790b656e0a7ce42267737577fc7a52b891e97644ec418eff7ec","impliedFormat":99},{"version":"ec948ee7e92d0888f92d4a490fdd0afb27fbf6d7aabebe2347a3e8ac82c36db9","impliedFormat":99},{"version":"03ef2386c683707ce741a1c30cb126e8c51a908aa0acc01c3471fafb9baaacd5","impliedFormat":99},{"version":"66a372e03c41d2d5e920df5282dadcec2acae4c629cb51cab850825d2a144cea","impliedFormat":99},{"version":"ddf9b157bd4c06c2e4646c9f034f36267a0fbd028bd4738214709de7ea7c548b","impliedFormat":99},{"version":"3e795aac9be23d4ad9781c00b153e7603be580602e40e5228e2dafe8a8e3aba1","impliedFormat":99},{"version":"98c461ec5953dfb1b5d5bca5fee0833c8a932383b9e651ca6548e55f1e2c71c3","impliedFormat":99},{"version":"5c42107b46cb1d36b6f1dee268df125e930b81f9b47b5fa0b7a5f2a42d556c10","impliedFormat":99},{"version":"7e32f1251d1e986e9dd98b6ff25f62c06445301b94aeebdf1f4296dbd2b8652f","impliedFormat":99},{"version":"2f7e328dda700dcb2b72db0f58c652ae926913de27391bd11505fc5e9aae6c33","impliedFormat":99},{"version":"3de7190e4d37da0c316db53a8a60096dbcd06d1a50677ccf11d182fa26882080","impliedFormat":99},{"version":"a9d6f87e59b32b02c861aade3f4477d7277c30d43939462b93f48644fa548c58","impliedFormat":99},{"version":"2bce8fd2d16a9432110bbe0ba1e663fd02f7d8b8968cd10178ea7bc306c4a5df","impliedFormat":99},{"version":"798bedbf45a8f1e55594e6879cd46023e8767757ecce1d3feaa78d16ad728703","impliedFormat":99},{"version":"62723d5ac66f7ed6885a3931dd5cfa017797e73000d590492988a944832e8bc2","impliedFormat":99},{"version":"03db8e7df7514bf17fc729c87fff56ca99567b9aa50821f544587a666537c233","impliedFormat":99},{"version":"9b1f311ba4409968b68bf20b5d892dbd3c5b1d65c673d5841c7dbde351bc0d0b","impliedFormat":99},{"version":"2d1e8b5431502739fe335ceec0aaded030b0f918e758a5d76f61effa0965b189","impliedFormat":99},{"version":"e725839b8f884dab141b42e9d7ff5659212f6e1d7b4054caa23bc719a4629071","impliedFormat":99},{"version":"4fa38a0b8ae02507f966675d0a7d230ed67c92ab8b5736d99a16c5fbe2b42036","impliedFormat":99},{"version":"50ec1e8c23bad160ddedf8debeebc722becbddda127b8fdce06c23eacd3fe689","impliedFormat":99},{"version":"9a0aea3a113064fd607f41375ade308c035911d3c8af5ae9db89593b5ca9f1f9","impliedFormat":99},{"version":"8d643903b58a0bf739ce4e6a8b0e5fb3fbdfaacbae50581b90803934b27d5b89","impliedFormat":99},{"version":"19de2915ccebc0a1482c2337b34cb178d446def2493bf775c4018a4ea355adb8","impliedFormat":99},{"version":"9be8fc03c8b5392cd17d40fd61063d73f08d0ee3457ecf075dcb3768ae1427bd","impliedFormat":99},{"version":"a2d89a8dc5a993514ca79585039eea083a56822b1d9b9d9d85b14232e4782cbe","impliedFormat":99},{"version":"f526f20cae73f17e8f38905de4c3765287575c9c4d9ecacee41cfda8c887da5b","impliedFormat":99},{"version":"d9ec0978b7023612b9b83a71fee8972e290d02f8ff894e95cdd732cd0213b070","impliedFormat":99},{"version":"7ab10c473a058ec8ac4790b05cae6f3a86c56be9b0c0a897771d428a2a48a9f9","impliedFormat":99},{"version":"451d7a93f8249d2e1453b495b13805e58f47784ef2131061821b0e456a9fd0e1","impliedFormat":99},{"version":"21c56fe515d227ed4943f275a8b242d884046001722a4ba81f342a08dbe74ae2","impliedFormat":99},{"version":"d8311f0c39381aa1825081c921efde36e618c5cf46258c351633342a11601208","impliedFormat":99},{"version":"6b50c3bcc92dc417047740810596fcb2df2502aa3f280c9e7827e87896da168a","impliedFormat":99},{"version":"18a6b318d1e7b31e5749a52be0cf9bbce1b275f63190ef32e2c79db0579328ca","impliedFormat":99},{"version":"6a2d0af2c27b993aa85414f3759898502aa198301bc58b0d410948fe908b07b0","impliedFormat":99},{"version":"2da11b6f5c374300e5e66a6b01c3c78ec21b5d3fec0748a28cc28e00be73e006","impliedFormat":99},{"version":"0729691b39c24d222f0b854776b00530877217bfc30aac1dc7fa2f4b1795c536","impliedFormat":99},{"version":"ca45bb5c98c474d669f0e47615e4a5ae65d90a2e78531fda7862ee43e687a059","impliedFormat":99},{"version":"c1c058b91d5b9a24c95a51aea814b0ad4185f411c38ac1d5eef0bf3cebec17dc","impliedFormat":99},{"version":"3ab0ed4060b8e5b5e594138aab3e7f0262d68ad671d6678bcda51568d4fc4ccc","impliedFormat":99},{"version":"e2bf1faba4ff10a6020c41df276411f641d3fdce5c6bae1db0ec84a0bf042106","impliedFormat":99},{"version":"80b0a8fe14d47a71e23d7c3d4dcee9584d4282ef1d843b70cab1a42a4ea1588c","impliedFormat":99},{"version":"a0f02a73f6e3de48168d14abe33bf5970fdacdb52d7c574e908e75ad571e78f7","impliedFormat":99},{"version":"c728002a759d8ec6bccb10eed56184e86aeff0a762c1555b62b5d0fa9d1f7d64","impliedFormat":99},{"version":"586f94e07a295f3d02f847f9e0e47dbf14c16e04ccc172b011b3f4774a28aaea","impliedFormat":99},{"version":"cfe1a0f4ed2df36a2c65ea6bc235dbb8cf6e6c25feb6629989f1fa51210b32e7","impliedFormat":99},{"version":"8ba69c9bf6de79c177329451ffde48ddab7ec495410b86972ded226552f664df","impliedFormat":99},{"version":"15111cbe020f8802ad1d150524f974a5251f53d2fe10eb55675f9df1e82dbb62","impliedFormat":99},{"version":"782dc153c56a99c9ed07b2f6f497d8ad2747764966876dbfef32f3e27ce11421","impliedFormat":99},{"version":"cc2db30c3d8bb7feb53a9c9ff9b0b859dd5e04c83d678680930b5594b2bf99cb","impliedFormat":99},{"version":"46909b8c85a6fd52e0807d18045da0991e3bdc7373435794a6ba425bc23cc6be","impliedFormat":99},{"version":"e4e511ff63bb6bd69a2a51e472c6044298bca2c27835a34a20827bc3ef9b7d13","impliedFormat":99},{"version":"2c86f279d7db3c024de0f21cd9c8c2c972972f842357016bfbbd86955723b223","impliedFormat":99},{"version":"112c895cff9554cf754f928477c7d58a21191c8089bffbf6905c87fe2dc6054f","impliedFormat":99},{"version":"8cfc293b33082003cacbf7856b8b5e2d6dd3bde46abbd575b0c935dc83af4844","impliedFormat":99},{"version":"d2c5c53f85ce0474b3a876d76c4fc44ff7bb766b14ed1bf495f9abac181d7f5f","impliedFormat":99},{"version":"3c523f27926905fcbe20b8301a0cc2da317f3f9aea2273f8fc8d9ae88b524819","impliedFormat":99},{"version":"9ca0d706f6b039cc52552323aeccb4db72e600b67ddc7a54cebc095fc6f35539","impliedFormat":99},{"version":"a64909a9f75081342ddd061f8c6b49decf0d28051bc78e698d347bdcb9746577","impliedFormat":99},{"version":"7d8d55ae58766d0d52033eae73084c4db6a93c4630a3e17f419dd8a0b2a4dcd8","impliedFormat":99},{"version":"b8b5c8ba972d9ffff313b3c8a3321e7c14523fc58173862187e8d1cb814168ac","impliedFormat":99},{"version":"9c42c0fa76ee36cf9cc7cc34b1389fbb4bd49033ec124b93674ec635fabf7ffe","impliedFormat":99},{"version":"6184c8da9d8107e3e67c0b99dedb5d2dfe5ccf6dfea55c2a71d4037caf8ca196","impliedFormat":99},{"version":"4030ceea7bf41449c1b86478b786e3b7eadd13dfe5a4f8f5fe2eb359260e08b3","impliedFormat":99},{"version":"7bf516ec5dfc60e97a5bde32a6b73d772bd9de24a2e0ec91d83138d39ac83d04","impliedFormat":99},{"version":"e6a6fb3e6525f84edf42ba92e261240d4efead3093aca3d6eb1799d5942ba393","impliedFormat":99},{"version":"45df74648934f97d26800262e9b2af2f77ef7191d4a5c2eb1df0062f55e77891","impliedFormat":99},{"version":"3fe361e4e567f32a53af1f2c67ad62d958e3d264e974b0a8763d174102fe3b29","impliedFormat":99},{"version":"28b520acee4bc6911bfe458d1ad3ebc455fa23678463f59946ad97a327c9ab2b","impliedFormat":99},{"version":"121b39b1a9ad5d23ed1076b0db2fe326025150ef476dccb8bf87778fcc4f6dd7","impliedFormat":99},{"version":"f791f92a060b52aa043dde44eb60307938f18d4c7ac13df1b52c82a1e658953f","impliedFormat":99},{"version":"df09443e7743fd6adc7eb108e760084bacdf5914403b7aac5fbd4dc4e24e0c2c","impliedFormat":99},{"version":"eeb4ff4aa06956083eaa2aad59070361c20254b865d986bc997ee345dbd44cbb","impliedFormat":99},{"version":"ed84d5043444d51e1e5908f664addc4472c227b9da8401f13daa565f23624b6e","impliedFormat":99},{"version":"146bf888b703d8baa825f3f2fb1b7b31bda5dff803e15973d9636cdda33f4af3","impliedFormat":99},{"version":"b4ec8b7a8d23bdf7e1c31e43e5beac3209deb7571d2ccf2a9572865bf242da7c","impliedFormat":99},{"version":"3fba0d61d172091638e56fba651aa1f8a8500aac02147d29bd5a9cc0bc8f9ec2","impliedFormat":99},{"version":"a5a57deb0351b03041e0a1448d3a0cc5558c48e0ed9b79b69c99163cdca64ad8","impliedFormat":99},{"version":"9bcecf0cbc2bfc17e33199864c19549905309a0f9ecc37871146107aac6e05ae","impliedFormat":99},{"version":"d6a211db4b4a821e93c978add57e484f2a003142a6aef9dbfa1fe990c66f337b","impliedFormat":99},{"version":"bd4d10bd44ce3f630dd9ce44f102422cb2814ead5711955aa537a52c8d2cae14","impliedFormat":99},{"version":"08e4c39ab1e52eea1e528ee597170480405716bae92ebe7a7c529f490afff1e0","impliedFormat":99},{"version":"625bb2bc3867557ea7912bd4581288a9fca4f3423b8dffa1d9ed57fafc8610e3","impliedFormat":99},{"version":"d1992164ecc334257e0bef56b1fd7e3e1cea649c70c64ffc39999bb480c0ecdf","impliedFormat":99},{"version":"a53ff2c4037481eb357e33b85e0d78e8236e285b6428b93aa286ceea1db2f5dc","impliedFormat":99},{"version":"4fe608d524954b6857d78857efce623852fcb0c155f010710656f9db86e973a5","impliedFormat":99},{"version":"b53b62a9838d3f57b70cc456093662302abb9962e5555f5def046172a4fe0d4e","impliedFormat":99},{"version":"9866369eb72b6e77be2a92589c9df9be1232a1a66e96736170819e8a1297b61f","impliedFormat":99},{"version":"43abfbdf4e297868d780b8f4cfdd8b781b90ecd9f588b05e845192146a86df34","impliedFormat":99},{"version":"582419791241fb851403ae4a08d0712a63d4c94787524a7419c2bc8e0eb1b031","impliedFormat":99},{"version":"18437eeb932fe48590b15f404090db0ab3b32d58f831d5ffc157f63b04885ee5","impliedFormat":99},{"version":"0c5eaedf622d7a8150f5c2ec1f79ac3d51eea1966b0b3e61bfdea35e8ca213a7","impliedFormat":99},{"version":"fac39fc7a9367c0246de3543a6ee866a0cf2e4c3a8f64641461c9f2dac0d8aae","impliedFormat":99},{"version":"3b9f559d0200134f3c196168630997caedeadc6733523c8b6076a09615d5dec8","impliedFormat":99},{"version":"932af64286d9723da5ef7b77a0c4229829ce8e085e6bcc5f874cb0b83e8310d4","impliedFormat":99},{"version":"adeb9278f11f5561157feee565171c72fd48f5fe34ed06f71abf24e561fcaa1e","impliedFormat":99},{"version":"2269fef79b4900fc6b08c840260622ca33524771ff24fda5b9101ad98ea551f3","impliedFormat":99},{"version":"73d47498a1b73d5392d40fb42a3e7b009ae900c8423f4088c4faa663cc508886","impliedFormat":99},{"version":"7efc34cdc4da0968c3ba687bc780d5cacde561915577d8d1c1e46c7ac931d023","impliedFormat":99},{"version":"3c20a3bb0c50c819419f44aa55acc58476dad4754a16884cef06012d02b0722f","impliedFormat":99},{"version":"4569abf6bc7d51a455503670f3f1c0e9b4f8632a3b030e0794c61bfbba2d13be","impliedFormat":99},{"version":"98b2297b4dc1404078a54b61758d8643e4c1d7830af724f3ed2445d77a7a2d57","impliedFormat":99},{"version":"952ba89d75f1b589e07070fea2d8174332e3028752e76fd46e1c16cc51e6e2af","impliedFormat":99},{"version":"b6c9a2deefb6a57ff68d2a38d33c34407b9939487fc9ee9f32ba3ecf2987a88a","impliedFormat":99},{"version":"f6b371377bab3018dac2bca63e27502ecbd5d06f708ad7e312658d3b5315d948","impliedFormat":99},{"version":"31947dd8f1c8eeb7841e1f139a493a73bd520f90e59a6415375d0d8e6a031f01","impliedFormat":99},{"version":"95cd83b807e10b1af408e62caf5fea98562221e8ddca9d7ccc053d482283ddda","impliedFormat":99},{"version":"19287d6b76288c2814f1633bdd68d2b76748757ffd355e73e41151644e4773d6","impliedFormat":99},{"version":"fc4e6ec7dade5f9d422b153c5d8f6ad074bd9cc4e280415b7dc58fb5c52b5df1","impliedFormat":99},{"version":"3aea973106e1184db82d8880f0ca134388b6cbc420f7309d1c8947b842886349","impliedFormat":99},{"version":"765e278c464923da94dda7c2b281ece92f58981642421ae097862effe2bd30fa","impliedFormat":99},{"version":"de260bed7f7d25593f59e859bd7c7f8c6e6bb87e8686a0fcafa3774cb5ca02d8","impliedFormat":99},{"version":"b5c341ce978f5777fbe05bc86f65e9906a492fa6b327bda3c6aae900c22e76c6","impliedFormat":99},{"version":"686ddbfaf88f06b02c6324005042f85317187866ca0f8f4c9584dd9479653344","impliedFormat":99},{"version":"7f789c0c1db29dd3aab6e159d1ba82894a046bf8df595ac48385931ae6ad83e0","impliedFormat":99},{"version":"8eb3057d4fe9b59b2492921b73a795a2455ebe94ccb3d01027a7866612ead137","impliedFormat":99},{"version":"1e43c5d7aee1c5ec20611e28b5417f5840c75d048de9d7f1800d6808499236f8","impliedFormat":99},{"version":"d42610a5a2bee4b71769968a24878885c9910cd049569daa2d2ee94208b3a7a5","impliedFormat":99},{"version":"f6ed95506a6ed2d40ed5425747529befaa4c35fcbbc1e0d793813f6d725690fa","impliedFormat":99},{"version":"a6fcc1cd6583939506c906dff1276e7ebdc38fbe12d3e108ba38ad231bd18d97","impliedFormat":99},{"version":"ed13354f0d96fb6d5878655b1fead51722b54875e91d5e53ef16de5b71a0e278","impliedFormat":99},{"version":"1193b4872c1fb65769d8b164ca48124c7ebacc33eae03abf52087c2b29e8c46c","impliedFormat":99},{"version":"af682dfabe85688289b420d939020a10eb61f0120e393d53c127f1968b3e9f66","impliedFormat":99},{"version":"0dca04006bf13f72240c6a6a502df9c0b49c41c3cab2be75e81e9b592dcd4ea8","impliedFormat":99},{"version":"79d6ac4a2a229047259116688f9cd62fda25422dee3ad304f77d7e9af53a41ef","impliedFormat":99},{"version":"64534c17173990dc4c3d9388d16675a059aac407031cfce8f7fdffa4ee2de988","impliedFormat":99},{"version":"ba46d160a192639f3ca9e5b640b870b1263f24ac77b6895ab42960937b42dcbb","impliedFormat":99},{"version":"5e5ddd6fc5b590190dde881974ab969455e7fad61012e32423415ae3d085b037","impliedFormat":99},{"version":"1c16fd00c42b60b96fe0fa62113a953af58ddf0d93b0a49cb4919cf5644616f0","impliedFormat":99},{"version":"eb240c0e6b412c57f7d9a9f1c6cd933642a929837c807b179a818f6e8d3a4e44","impliedFormat":99},{"version":"4a7bde5a1155107fc7d9483b8830099f1a6072b6afda5b78d91eb5d6549b3956","impliedFormat":99},{"version":"3c1baaffa9a24cc7ef9eea6b64742394498e0616b127ca630aca0e11e3298006","impliedFormat":99},{"version":"87ca1c31a326c898fa3feb99ec10750d775e1c84dbb7c4b37252bcf3742c7b21","impliedFormat":99},{"version":"d7bd26af1f5457f037225602035c2d7e876b80d02663ab4ca644099ad3a55888","impliedFormat":99},{"version":"2ad0a6b93e84a56b64f92f36a07de7ebcb910822f9a72ad22df5f5d642aff6f3","impliedFormat":99},{"version":"523d1775135260f53f672264937ee0f3dc42a92a39de8bee6c48c7ea60b50b5a","impliedFormat":99},{"version":"e441b9eebbc1284e5d995d99b53ed520b76a87cab512286651c4612d86cd408e","impliedFormat":99},{"version":"76f853ee21425c339a79d28e0859d74f2e53dee2e4919edafff6883dd7b7a80f","impliedFormat":99},{"version":"00cf042cd6ba1915648c8d6d2aa00e63bbbc300ea54d28ed087185f0f662e080","impliedFormat":99},{"version":"f57e6707d035ab89a03797d34faef37deefd3dd90aa17d90de2f33dce46a2c56","impliedFormat":99},{"version":"cc8b559b2cf9380ca72922c64576a43f000275c72042b2af2415ce0fb88d7077","impliedFormat":99},{"version":"1a337ca294c428ba8f2eb01e887b28d080ee4a4307ae87e02e468b1d26af4a74","impliedFormat":99},{"version":"5a15362fc2e72765a908c0d4dd89e3ab3b763e8bc8c23f19234a709ecfd202fe","impliedFormat":99},{"version":"2dffdfe62ac8af0943853234519616db6fd8958fc7ff631149fd8364e663f361","impliedFormat":99},{"version":"5dbdb2b2229b5547d8177c34705272da5a10b8d0033c49efbc9f6efba5e617f2","impliedFormat":99},{"version":"6fc0498cd8823d139004baff830343c9a0d210c687b2402c1384fb40f0aa461c","impliedFormat":99},{"version":"8492306a4864a1dc6fc7e0cc0de0ae9279cbd37f3aae3e9dc1065afcdc83dddc","impliedFormat":99},{"version":"c011b378127497d6337a93f020a05f726db2c30d55dc56d20e6a5090f05919a6","impliedFormat":99},{"version":"f4556979e95a274687ae206bbab2bb9a71c3ad923b92df241d9ab88c184b3f40","impliedFormat":99},{"version":"50e82bb6e238db008b5beba16d733b77e8b2a933c9152d1019cf8096845171a4","impliedFormat":99},{"version":"d6011f8b8bbf5163ef1e73588e64a53e8bf1f13533c375ec53e631aad95f1375","impliedFormat":99},{"version":"693cd7936ac7acfa026d4bcb5801fce71cec49835ba45c67af1ef90dbfd30af7","impliedFormat":99},{"version":"195e2cf684ecddfc1f6420564535d7c469f9611ce7a380d6e191811f84556cd2","impliedFormat":99},{"version":"1dc6b6e7b2a7f2962f31c77f4713f3a5a132bbe14c00db75d557568fe82e4311","impliedFormat":99},{"version":"add93b1180e9aaac2dae4ef3b16f7655893e2ecbe62bd9e48366c305f0063d89","impliedFormat":99},{"version":"594bd896fe37c970aafb7a376ebeec4c0d636b62a5f611e2e27d30fb839ad8a5","impliedFormat":99},{"version":"b1c6a6faf60542ba4b4271db045d7faea56e143b326ef507d2797815250f3afc","impliedFormat":99},{"version":"8c8b165beb794260f462679329b131419e9f5f35212de11c4d53e6d4d9cbedf6","impliedFormat":99},{"version":"ee5a4cf57d49fcf977249ab73c690a59995997c4672bb73fcaaf2eed65dbd1b2","impliedFormat":99},{"version":"f9f36051f138ab1c40b76b230c2a12b3ce6e1271179f4508da06a959f8bee4c1","impliedFormat":99},{"version":"9dc2011a3573d271a45c12656326530c0930f92539accbec3531d65131a14a14","impliedFormat":99},{"version":"091521ce3ede6747f784ae6f68ad2ea86bbda76b59d2bf678bcad2f9d141f629","impliedFormat":99},{"version":"202c2be951f53bafe943fb2c8d1245e35ed0e4dfed89f48c9a948e4d186dd6d4","impliedFormat":99},{"version":"c618aead1d799dbf4f5b28df5a6b9ce13d72722000a0ec3fe90a8115b1ea9226","impliedFormat":99},{"version":"9b0bf59708549c3e77fddd36530b95b55419414f88bbe5893f7bc8b534617973","impliedFormat":99},{"version":"7e216f67c4886f1bde564fb4eebdd6b185f262fe85ad1d6128cad9b229b10354","impliedFormat":99},{"version":"cd51e60b96b4d43698df74a665aa7a16604488193de86aa60ec0c44d9f114951","impliedFormat":99},{"version":"b63341fb6c7ba6f2aeabd9fc46b43e6cc2d2b9eec06534cfd583d9709f310ec2","impliedFormat":99},{"version":"be2af50c81b15bcfe54ad60f53eb1c72dae681c72d0a9dce1967825e1b5830a3","impliedFormat":99},{"version":"be5366845dfb9726f05005331b9b9645f237f1ddc594c0def851208e8b7d297b","impliedFormat":99},{"version":"5ddd536aaeadd4bf0f020492b3788ed209a7050ce27abec4e01c7563ff65da81","impliedFormat":99},{"version":"e243b24da119c1ef0d79af2a45217e50682b139cb48e7607efd66cc01bd9dcda","impliedFormat":99},{"version":"5b1398c8257fd180d0bf62e999fe0a89751c641e87089a83b24392efda720476","impliedFormat":99},{"version":"1588b1359f8507a16dbef67cd2759965fc2e8d305e5b3eb71be5aa9506277dff","impliedFormat":99},{"version":"4c99f2524eee1ec81356e2b4f67047a4b7efaf145f1c4eb530cd358c36784423","impliedFormat":99},{"version":"b30c6b9f6f30c35d6ef84daed1c3781e367f4360171b90598c02468b0db2fc3d","impliedFormat":99},{"version":"79c0d32274ccfd45fae74ac61d17a2be27aea74c70806d22c43fc625b7e9f12a","impliedFormat":99},{"version":"1b7e3958f668063c9d24ac75279f3e610755b0f49b1c02bb3b1c232deb958f54","impliedFormat":99},{"version":"779d4022c3d0a4df070f94858a33d9ebf54af3664754536c4ce9fd37c6f4a8db","impliedFormat":99},{"version":"e662f063d46aa8c088edffdf1d96cb13d9a2cbf06bc38dc6fc62b4d125fb7b49","impliedFormat":99},{"version":"d1d612df1e41c90d9678b07740d13d4f8e6acec2f17390d4ff4be5c889a6d37d","impliedFormat":99},{"version":"c95933fe140918892d569186f17b70ef6b1162f851a0f13f6a89e8f4d599c5a1","impliedFormat":99},{"version":"1d8d30677f87c13c2786980a80750ac1e281bdb65aa013ea193766fe9f0edd74","impliedFormat":99},{"version":"4661673cbc984b8a6ee5e14875a71ed529b64e7f8e347e12c0db4cecc25ad67d","impliedFormat":99},{"version":"7f980a414274f0f23658baa9a16e21d828535f9eac538e2eab2bb965325841db","impliedFormat":99},{"version":"20fb747a339d3c1d4a032a31881d0c65695f8167575e01f222df98791a65da9b","impliedFormat":99},{"version":"dd4e7ebd3f205a11becf1157422f98db675a626243d2fbd123b8b93efe5fb505","impliedFormat":99},{"version":"43ec6b74c8d31e88bb6947bb256ad78e5c6c435cbbbad991c3ff39315b1a3dba","impliedFormat":99},{"version":"b27242dd3af2a5548d0c7231db7da63d6373636d6c4e72d9b616adaa2acef7e1","impliedFormat":99},{"version":"e0ee7ba0571b83c53a3d6ec761cf391e7128d8f8f590f8832c28661b73c21b68","impliedFormat":99},{"version":"072bfd97fc61c894ef260723f43a416d49ebd8b703696f647c8322671c598873","impliedFormat":99},{"version":"e70875232f5d5528f1650dd6f5c94a5bed344ecf04bdbb998f7f78a3c1317d02","impliedFormat":99},{"version":"8e495129cb6cd8008de6f4ff8ce34fe1302a9e0dcff8d13714bd5593be3f7898","impliedFormat":99},{"version":"0345bc0b1067588c4ea4c48e34425d3284498c629bc6788ebc481c59949c9037","impliedFormat":99},{"version":"e30f5b5d77c891bc16bd65a2e46cd5384ea57ab3d216c377f482f535db48fc8f","impliedFormat":99},{"version":"f113afe92ee919df8fc29bca91cab6b2ffbdd12e4ac441d2bb56121eb5e7dbe3","impliedFormat":99},{"version":"49d567cc002efb337f437675717c04f207033f7067825b42bb59c9c269313d83","impliedFormat":99},{"version":"1d248f707d02dc76555298a934fba0f337f5028bb1163ce59cd7afb831c9070f","impliedFormat":99},{"version":"5d8debffc9e7b842dc0f17b111673fe0fc0cca65e67655a2b543db2150743385","impliedFormat":99},{"version":"5fccbedc3eb3b23bc6a3a1e44ceb110a1f1a70fa8e76941dce3ae25752caa7a9","impliedFormat":99},{"version":"f4031b95f3bab2b40e1616bd973880fb2f1a97c730bac5491d28d6484fac9560","impliedFormat":99},{"version":"dbe75b3c5ed547812656e7945628f023c4cd0bc1879db0db3f43a57fb8ec0e2b","impliedFormat":99},{"version":"b754718a546a1939399a6d2a99f9022d8a515f2db646bab09f7d2b5bff3cbb82","impliedFormat":99},{"version":"2eef10fb18ed0b4be450accf7a6d5bcce7b7f98e02cac4e6e793b7ad04fc0d79","impliedFormat":99},{"version":"c46f471e172c3be12c0d85d24876fedcc0c334b0dab48060cdb1f0f605f09fed","impliedFormat":99},{"version":"7d6ddeead1d208588586c58c26e4a23f0a826b7a143fb93de62ed094d0056a33","impliedFormat":99},{"version":"7c5782291ff6e7f2a3593295681b9a411c126e3736b83b37848032834832e6b9","impliedFormat":99},{"version":"3a3f09df6258a657dd909d06d4067ee360cd2dccc5f5d41533ae397944a11828","impliedFormat":99},{"version":"ea54615be964503fec7bce04336111a6fa455d3e8d93d44da37b02c863b93eb8","impliedFormat":99},{"version":"2a83694bc3541791b64b0e57766228ea23d92834df5bf0b0fcb93c5bb418069c","impliedFormat":99},{"version":"b5913641d6830e7de0c02366c08b1d26063b5758132d8464c938e78a45355979","impliedFormat":99},{"version":"46c095d39c1887979d9494a824eda7857ec13fb5c20a6d4f7d02c2975309bf45","impliedFormat":99},{"version":"f6e02ca076dc8e624aa38038e3488ebd0091e2faea419082ed764187ba8a6500","impliedFormat":99},{"version":"4d49e8a78aba1d4e0ad32289bf8727ae53bc2def9285dff56151a91e7d770c3e","impliedFormat":99},{"version":"63315cf08117cc728eab8f3eec8801a91d2cd86f91d0ae895d7fd928ab54596d","impliedFormat":99},{"version":"a14a6f3a5636bcaebfe9ec2ccfa9b07dc94deb1f6c30358e9d8ea800a1190d5e","impliedFormat":99},{"version":"21206e7e81876dabf2a7af7aa403f343af1c205bdcf7eff24d9d7f4eee6214c4","impliedFormat":99},{"version":"cd0a9f0ffec2486cad86b7ef1e4da42953ffeb0eb9f79f536e16ff933ec28698","impliedFormat":99},{"version":"f609a6ec6f1ab04dba769e14d6b55411262fd4627a099e333aa8876ea125b822","impliedFormat":99},{"version":"6d8052bb814be030c64cb22ca0e041fe036ad3fc8d66208170f4e90d0167d354","impliedFormat":99},{"version":"851f72a5d3e8a2bf7eeb84a3544da82628f74515c92bdf23c4a40af26dcc1d16","impliedFormat":99},{"version":"59692a7938aab65ea812a8339bbc63c160d64097fe5a457906ea734d6f36bcd4","impliedFormat":99},{"version":"8cb3b95e610c44a9986a7eab94d7b8f8462e5de457d5d10a0b9c6dd16bde563b","impliedFormat":99},{"version":"f571713abd9a676da6237fe1e624d2c6b88c0ca271c9f1acc1b4d8efeea60b66","impliedFormat":99},{"version":"16c5d3637d1517a3d17ed5ebcfbb0524f8a9997a7b60f6100f7c5309b3bb5ac8","impliedFormat":99},{"version":"ca1ec669726352c8e9d897f24899abf27ad15018a6b6bcf9168d5cd1242058ab","impliedFormat":99},{"version":"bffb1b39484facf6d0c5d5feefe6c0736d06b73540b9ce0cf0f12da2edfd8e1d","impliedFormat":99},{"version":"f1663c030754f6171b8bb429096c7d2743282de7733bccd6f67f84a4c588d96e","impliedFormat":99},{"version":"dd09693285e58504057413c3adc84943f52b07d2d2fd455917f50fa2a63c9d69","impliedFormat":99},{"version":"d94c94593d03d44a03810a85186ae6d61ebeb3a17a9b210a995d85f4b584f23d","impliedFormat":99},{"version":"c7c3bf625a8cb5a04b1c0a2fbe8066ecdbb1f383d574ca3ffdabe7571589a935","impliedFormat":99},{"version":"7a2f39a4467b819e873cd672c184f45f548511b18f6a408fe4e826136d0193bb","impliedFormat":99},{"version":"f8a0ae0d3d4993616196619da15da60a6ec5a7dfaf294fe877d274385eb07433","impliedFormat":99},{"version":"2cca80de38c80ef6c26deb4e403ca1ff4efbe3cf12451e26adae5e165421b58d","impliedFormat":99},{"version":"0070d3e17aa5ad697538bf865faaff94c41f064db9304b2b949eb8bcccb62d34","impliedFormat":99},{"version":"53df93f2db5b7eb8415e98242c1c60f6afcac2db44bce4a8830c8f21eee6b1dd","impliedFormat":99},{"version":"d67bf28dc9e6691d165357424c8729c5443290367344263146d99b2f02a72584","impliedFormat":99},{"version":"932557e93fbdf0c36cc29b9e35950f6875425b3ac917fa0d3c7c2a6b4f550078","impliedFormat":99},{"version":"e3dc7ec1597fb61de7959335fb7f8340c17bebf2feb1852ed8167a552d9a4a25","impliedFormat":99},{"version":"b64e15030511c5049542c2e0300f1fe096f926cf612662884f40227267f5cd9f","impliedFormat":99},{"version":"1932796f09c193783801972a05d8fb1bfef941bb46ac76fbe1abb0b3bfb674fa","impliedFormat":99},{"version":"d9575d5787311ee7d61ad503f5061ebcfaf76b531cfecce3dc12afb72bb2d105","impliedFormat":99},{"version":"5b41d96c9a4c2c2d83f1200949f795c3b6a4d2be432b357ad1ab687e0f0de07c","impliedFormat":99},{"version":"38ec829a548e869de4c5e51671245a909644c8fb8e7953259ebb028d36b4dd06","impliedFormat":99},{"version":"20c2c5e44d37dac953b516620b5dba60c9abd062235cdf2c3bfbf722d877a96b","impliedFormat":99},{"version":"875fe6f7103cf87c1b741a0895fda9240fed6353d5e7941c8c8cbfb686f072b4","impliedFormat":99},{"version":"c0ccccf8fbcf5d95f88ed151d0d8ce3015aa88cf98d4fd5e8f75e5f1534ee7ae","impliedFormat":99},{"version":"1b1f4aba21fd956269ced249b00b0e5bfdbd5ebd9e628a2877ab1a2cf493c919","impliedFormat":99},{"version":"939e3299952dff0869330e3324ba16efe42d2cf25456d7721d7f01a43c1b0b34","impliedFormat":99},{"version":"f0a9b52faec508ba22053dedfa4013a61c0425c8b96598cef3dea9e4a22637c6","impliedFormat":99},{"version":"d5b302f50db61181adc6e209af46ae1f27d7ef3d822de5ea808c9f44d7d219fd","impliedFormat":99},{"version":"19131632ba492c83e8eeadf91a481def0e0b39ffc3f155bc20a7f640e0570335","impliedFormat":99},{"version":"4581c03abea21396c3e1bb119e2fd785a4d91408756209cbeed0de7070f0ab5b","impliedFormat":99},{"version":"ebcd3b99e17329e9d542ef2ccdd64fddab7f39bc958ee99bbdb09056c02d6e64","impliedFormat":99},{"version":"4b148999deb1d95b8aedd1a810473a41d9794655af52b40e4894b51a8a4e6a6d","impliedFormat":99},{"version":"1781cc99a0f3b4f11668bb37cca7b8d71f136911e87269e032f15cf5baa339bf","impliedFormat":99},{"version":"33f1b7fa96117d690035a235b60ecd3cd979fb670f5f77b08206e4d8eb2eb521","impliedFormat":99},{"version":"01429b306b94ff0f1f5548ce5331344e4e0f5872b97a4776bd38fd2035ad4764","impliedFormat":99},{"version":"c1bc4f2136de7044943d784e7a18cb8411c558dbb7be4e4b4876d273cbd952af","impliedFormat":99},{"version":"5470f84a69b94643697f0d7ec2c8a54a4bea78838aaa9170189b9e0a6e75d2cf","impliedFormat":99},{"version":"36aaa44ee26b2508e9a6e93cd567e20ec700940b62595caf962249035e95b5e3","impliedFormat":99},{"version":"f8343562f283b7f701f86ad3732d0c7fd000c20fe5dc47fa4ed0073614202b4d","impliedFormat":99},{"version":"a53c572630a78cd99a25b529069c1e1370f8a5d8586d98e798875f9052ad7ad1","impliedFormat":99},{"version":"4ad3451d066711dde1430c544e30e123f39e23c744341b2dfd3859431c186c53","impliedFormat":99},{"version":"8069cbef9efa7445b2f09957ffbc27b5f8946fdbade4358fb68019e23df4c462","impliedFormat":99},{"version":"cd8b4e7ad04ba9d54eb5b28ac088315c07335b837ee6908765436a78d382b4c3","impliedFormat":99},{"version":"d533d8f8e5c80a30c51f0cbfe067b60b89b620f2321d3a581b5ba9ac8ffd7c3a","impliedFormat":99},{"version":"33f49f22fdda67e1ddbacdcba39e62924793937ea7f71f4948ed36e237555de3","impliedFormat":99},{"version":"710c31d7c30437e2b8795854d1aca43b540cb37cefd5900f09cfcd9e5b8540c4","impliedFormat":99},{"version":"b2c03a0e9628273bc26a1a58112c311ffbc7a0d39938f3878837ab14acf3bc41","impliedFormat":99},{"version":"a93beb0aa992c9b6408e355ea3f850c6f41e20328186a8e064173106375876c2","impliedFormat":99},{"version":"efdcba88fcd5421867898b5c0e8ea6331752492bd3547942dea96c7ebcb65194","impliedFormat":99},{"version":"a98e777e7a6c2c32336a017b011ba1419e327320c3556b9139413e48a8460b9a","impliedFormat":99},{"version":"ea44f7f8e1fe490516803c06636c1b33a6b82314366be1bd6ffa4ba89bc09f86","impliedFormat":99},{"version":"c25f22d78cc7f46226179c33bef0e4b29c54912bde47b62e5fdaf9312f22ffcb","impliedFormat":99},{"version":"d57579cfedc5a60fda79be303080e47dfe0c721185a5d95276523612228fcefc","impliedFormat":99},{"version":"a41630012afe0d4a9ff14707f96a7e26e1154266c008ddbd229e3f614e4d1cf7","impliedFormat":99},{"version":"298a858633dfa361bb8306bbd4cfd74f25ab7cc20631997dd9f57164bc2116d1","impliedFormat":99},{"version":"921782c45e09940feb232d8626a0b8edb881be2956520c42c44141d9b1ddb779","impliedFormat":99},{"version":"06117e4cc7399ce1c2b512aa070043464e0561f956bda39ef8971a2fcbcdbf2e","impliedFormat":99},{"version":"daccf332594b304566c7677c2732fed6e8d356da5faac8c5f09e38c2f607a4ab","impliedFormat":99},{"version":"4386051a0b6b072f35a2fc0695fecbe4a7a8a469a1d28c73be514548e95cd558","impliedFormat":99},{"version":"78e41de491fe25947a7fd8eeef7ebc8f1c28c1849a90705d6e33f34b1a083b90","impliedFormat":99},{"version":"3ccd198e0a693dd293ed22e527c8537c76b8fe188e1ebf20923589c7cfb2c270","impliedFormat":99},{"version":"2ebf2ee015d5c8008428493d4987e2af9815a76e4598025dd8c2f138edc1dcae","impliedFormat":99},{"version":"0dcc8f61382c9fcdafd48acc54b6ffda69ca4bb7e872f8ad12fb011672e8b20c","impliedFormat":99},{"version":"9db563287eb527ead0bcb9eb26fbec32f662f225869101af3cabcb6aee9259cf","impliedFormat":99},{"version":"068489bec523be43f12d8e4c5c337be4ff6a7efb4fe8658283673ae5aae14b85","impliedFormat":99},{"version":"838212d0dc5b97f7c5b5e29a89953de3906f72fce13c5ae3c5ade346f561d226","impliedFormat":99},{"version":"57ae71d27ee71b7d1f2c6d867ddafbbfbaa629ad75565e63a508dbaa3ef9f859","impliedFormat":99},{"version":"60924ca0c60f0674f208bfa1eaaa54e6973ced7650df7c7a81ae069730ef665a","impliedFormat":99},{"version":"e3181c7595a89dd03ba9a20eb5065fa37e0b0a514261bed774f6ae2241634470","impliedFormat":99},{"version":"c42d5cbf94816659c01f7c2298d0370247f1a981f8ca6370301b7a03b3ced950","impliedFormat":99},{"version":"18c18ab0341fd5fdfefb5d992c365be1696bfe000c7081c964582b315e33f8f2","impliedFormat":99},{"version":"dafbd4199902d904e3d4a233b5faf5dc4c98847fcd8c0ddd7617b2aed50e90d8","impliedFormat":99},{"version":"9fc866f9783d12d0412ed8d68af5e4c9e44f0072d442b0c33c3bda0a5c8cae15","impliedFormat":99},{"version":"5fc13d24a2d0328eac00c4e73cc052a987fbced2151bc0d3b7eb8f3ba4d0f4e2","impliedFormat":99},{"version":"ddc78d29af824ad7587152ea523ed5d60f2bc0148d8741c5dacf9b5b44587b1b","impliedFormat":99},{"version":"019b522e3783e5519966927ceeb570eefcc64aba3f9545828a5fb4ae1fde53c6","impliedFormat":99},{"version":"b34623cc86497a5123de522afba770390009a56eebddba38d2aa5798b70b0a87","impliedFormat":99},{"version":"d2a8cbeb0c0caaf531342062b4b5c227118862879f6a25033e31fad00797b7eb","impliedFormat":99},{"version":"14891c20f15be1d0d42ecbbd63de1c56a4d745e3ea2b4c56775a4d5d36855630","impliedFormat":99},{"version":"e55a1f6b198a39e38a3cea3ffe916aab6fde7965c827db3b8a1cacf144a67cd9","impliedFormat":99},{"version":"f7910ccfe56131e99d52099d24f3585570dc9df9c85dd599a387b4499596dd4d","impliedFormat":99},{"version":"9409ac347c5779f339112000d7627f17ede6e39b0b6900679ce5454d3ad2e3c9","impliedFormat":99},{"version":"22dfe27b0aa1c669ce2891f5c89ece9be18074a867fe5dd8b8eb7c46be295ca1","impliedFormat":99},{"version":"684a5c26ce2bb7956ef6b21e7f2d1c584172cd120709e5764bc8b89bac1a10eb","impliedFormat":99},{"version":"caee92604debc32ccab33dc2128727eb3c82e56d9af95f91f0177033893ebb42","impliedFormat":99},{"version":"c66be51e3d121c163a4e140b6b520a92e1a6a8a8862d44337be682e6f5ec290a","impliedFormat":99},{"version":"66e486a9c9a86154dc9780f04325e61741f677713b7e78e515938bf54364fee2","impliedFormat":99},{"version":"d211bc80b6b6e98445df46fe9dd3091944825dd924986a1c15f9c66d7659c495","impliedFormat":99},{"version":"8dd2b72f5e9bf88939d066d965144d07518e180efec3e2b6d06ae5e725d84c7d","impliedFormat":99},{"version":"949cb88e315ab1a098c3aa4a8b02496a32b79c7ef6d189eee381b96471a7f609","impliedFormat":99},{"version":"bc43af2a5fa30a36be4a3ed195ff29ffb8067bf4925aa350ace9d9f18f380cc2","impliedFormat":99},{"version":"b9beb5d678e6cf67901f1154f91dff455378e6aa89b20da56ed1400f3fb1f3cf","impliedFormat":99},{"version":"8428e71f6d1b63acf55ceb56244aad9cf07678cf9626166e4aded15e3d252f8a","impliedFormat":99},{"version":"11505212ab24aa0f06d719a09add4be866e26f0fc15e96a1a2a8522c0c6a73a8","impliedFormat":99},{"version":"4d647d8335edecd696fa7e59a7f2f2fea835d56d800aa2cb9278c8e5c6806815","impliedFormat":99},{"version":"c44bb0071cededc08236d57d1131c44339c1add98b029a95584dfe1462533575","impliedFormat":99},{"version":"7a4935af71877da3bbc53938af00e5d4f6d445ef850e1573a240447dcb137b5c","impliedFormat":99},{"version":"4e313033202712168ecc70a6d830964ad05c9c93f81d806d7a25d344f6352565","impliedFormat":99},{"version":"8a1fc69eaf8fc8d447e6f776fbfa0c1b12245d7f35f1dbfb18fbc2d941f5edd8","impliedFormat":99},{"version":"afb9b4c8bd38fb43d38a674de56e6f940698f91114fded0aa119de99c6cd049a","impliedFormat":99},{"version":"1d277860f19b8825d027947fca9928ee1f3bfaa0095e85a97dd7a681b0698dfc","impliedFormat":99},{"version":"6d32122bb1e7c0b38b6f126d166dff1f74c8020f8ba050248d182dcafc835d08","impliedFormat":99},{"version":"cfac5627d337b82d2fbeff5f0f638b48a370a8d72d653327529868a70c5bc0f8","impliedFormat":99},{"version":"8a826bc18afa4c5ed096ceb5d923e2791a5bae802219e588a999f535b1c80492","impliedFormat":99},{"version":"73e94021c55ab908a1b8c53792e03bf7e0d195fee223bdc5567791b2ccbfcdec","impliedFormat":99},{"version":"5f73eb47b37f3a957fe2ac6fe654648d60185908cab930fc01c31832a5cb4b10","impliedFormat":99},{"version":"cb6372a2460010a342ba39e06e1dcfd722e696c9d63b4a71577f9a3c72d09e0a","impliedFormat":99},{"version":"1e289698069f553f36bbf12ee0084c492245004a69409066faceb173d2304ec4","impliedFormat":99},{"version":"f1ca71145e5c3bba4d7f731db295d593c3353e9a618b40c4af0a4e9a814bb290","impliedFormat":99},{"version":"ac12a6010ff501e641f5a8334b8eaf521d0e0739a7e254451b6eea924c3035c7","impliedFormat":99},{"version":"97395d1e03af4928f3496cc3b118c0468b560765ab896ce811acb86f6b902b5c","impliedFormat":99},{"version":"7dcfbd6a9f1ce1ddf3050bd469aa680e5259973b4522694dc6291afe20a2ae28","impliedFormat":99},{"version":"6e545419ad200ae4614f8e14d32b7e67e039c26a872c0f93437b0713f54cde53","impliedFormat":99},{"version":"efc225581aae9bb47d421a1b9f278db0238bc617b257ce6447943e59a2d1621e","impliedFormat":99},{"version":"8833b88e26156b685bc6f3d6a014c2014a878ffbd240a01a8aee8a9091014e9c","impliedFormat":99},{"version":"7a2a42a1ac642a9c28646731bd77d9849cb1a05aa1b7a8e648f19ab7d72dd7dc","impliedFormat":99},{"version":"4d371c53067a3cc1a882ff16432b03291a016f4834875b77169a2d10bb1b023e","impliedFormat":99},{"version":"99b38f72e30976fd1946d7b4efe91aa227ecf0c9180e1dd6502c1d39f37445b4","impliedFormat":99},{"version":"df1bcf0b1c413e2945ce63a67a1c5a7b21dbbec156a97d55e9ea0eed90d2c604","impliedFormat":99},{"version":"6e2011a859fa435b1196da1720be944ed59c668bb42d2f2711b49a506b3e4e90","impliedFormat":99},{"version":"b4bfa90fac90c6e0d0185d2fe22f059fec67587cc34281f62294f9c4615a8082","impliedFormat":99},{"version":"036d363e409ebe316a6366aff5207380846f8f82e100c2e3db4af5fe0ad0c378","impliedFormat":99},{"version":"5ae6642588e4a72e5a62f6111cb750820034a7fbe56b5d8ec2bcb29df806ce52","impliedFormat":99},{"version":"6fca09e1abc83168caf36b751dec4ddda308b5714ec841c3ff0f3dc07b93c1b8","impliedFormat":99},{"version":"2f7268e6ac610c7122b6b416e34415ce42b51c56d080bef41786d2365f06772d","impliedFormat":99},{"version":"9a07957f75128ed0be5fc8a692a14da900878d5d5c21880f7c08f89688354aa4","impliedFormat":99},{"version":"8b6f3ae84eab35c50cf0f1b608c143fe95f1f765df6f753cd5855ae61b3efbe2","impliedFormat":99},{"version":"992491d83ff2d1e7f64a8b9117daee73724af13161f1b03171f0fa3ffe9b4e3e","impliedFormat":99},{"version":"12bcf6af851be8dd5f3e66c152bb77a83829a6a8ba8c5acc267e7b15e11aa9ab","impliedFormat":99},{"version":"e2704efc7423b077d7d9a21ddb42f640af1565e668d5ec85f0c08550eff8b833","impliedFormat":99},{"version":"704482f2a4a47287b195fa15c63de9188819072bc0f7635da3411ed9509bfa63","impliedFormat":99},{"version":"20c66936bdbdf6938b49053377bceea1009f491d89c2dff81efa36812a85f298","impliedFormat":99},{"version":"0c06897f7ab3830cef0701e0e083b2c684ed783ae820b306aedd501f32e9562d","impliedFormat":99},{"version":"56cc6eae48fd08fa709cf9163d01649f8d24d3fea5806f488d2b1b53d25e1d6c","impliedFormat":99},{"version":"57a925b13947b38c34277d93fb1e85d6f03f47be18ca5293b14082a1bd4a48f5","impliedFormat":99},{"version":"9d9d64c1fa76211dd529b6a24061b8d724e2110ee55d3829131bca47f3fe4838","impliedFormat":99},{"version":"c13042e244bb8cf65586e4131ef7aed9ca33bf1e029a43ed0ebab338b4465553","impliedFormat":99},{"version":"54be9b9c71a17cb2519b841fad294fa9dc6e0796ed86c8ac8dd9d8c0d1c3a631","impliedFormat":99},{"version":"10881be85efd595bef1d74dfa7b9a76a5ab1bfed9fb4a4ca7f73396b72d25b90","impliedFormat":99},{"version":"925e71eaa87021d9a1215b5cf5c5933f85fe2371ddc81c32d1191d7842565302","impliedFormat":99},{"version":"faed0b3f8979bfbfb54babcff9d91bd51fda90931c7716effa686b4f30a09575","impliedFormat":99},{"version":"53c72d68328780f711dbd39de7af674287d57e387ddc5a7d94f0ffd53d8d3564","impliedFormat":99},{"version":"51129924d359cdebdccbf20dbabc98c381b58bfebe2457a7defed57002a61316","impliedFormat":99},{"version":"7270a757071e3bc7b5e7a6175f1ac9a4ddf4de09f3664d80cb8805138f7d365b","impliedFormat":99},{"version":"ea7b5c6a79a6511cdeeedc47610370be1b0e932e93297404ef75c90f05fc1b61","impliedFormat":99},{"version":"385186398bf278346f83d74d0fa6733bc30d7403e391c70c13918ae784bcb538","signature":"3b67826fbf472e0f44d5cb98d65c6faae1129c3151c7aeed37e1311fd43a1ea0"},{"version":"a26d74bc8768e134734fa049d5a89fb674a560292f4bf1b39392416dc04cf49e","impliedFormat":99},{"version":"ea7f3d87bb25b8cf26c1b440de31b628c53b5e72e8f1ab1726356bf58acf5946","impliedFormat":99},{"version":"7ec047b73f621c526468517fea779fec2007dd05baa880989def59126c98ef79","impliedFormat":99},{"version":"8dd450de6d756cee0761f277c6dc58b0b5a66b8c274b980949318b8cad26d712","impliedFormat":99},{"version":"6b5f886fe41e2e767168e491fe6048398ed6439d44e006d9f51cc31265f08978","impliedFormat":99},{"version":"f4a1eba860f7493d19df42373ddde4f3c6f31aa574b608e55e5b2bd459bba587","impliedFormat":99},{"version":"6b863463764ae572b9ada405bf77aac37b5e5089a3ab420d0862e4471051393b","impliedFormat":99},{"version":"904d6ad970b6bd825449480488a73d9b98432357ab38cf8d31ffd651ae376ff5","impliedFormat":99},{"version":"2535fc1a5fe64892783ff8f61321b181c24f824e688a4a05ae738da33466605b","impliedFormat":99},{"version":"c9c151ff19977b78e8d6b108f7162f4daef60aea6c9dd4dcf9faa883ec885430","signature":"3bbc2674f9e5d598c0701114b0081a64cbc78fd3928a2d2e652ddfda70124dee"},{"version":"010e8535c69ce05389e404105a9e062d539051d7baa5bb6ddd977824ff9637cf","signature":"725cc348c4f0292d69186973e270ab4133fdf717790b22222f548dad1726b0e8"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"4a5aa16151dbec524bb043a5cbce2c3fec75957d175475c115a953aca53999a9","impliedFormat":99},{"version":"d4c744131c6161300510909aafe2c2cb6d819f2c7a8c2aeb75d4317004c7eff7","signature":"1913d3e9a871099126700f506a2c3b8fe9d47857253124e5787055b463b98b4c"},{"version":"a2741e97846b771388d1b7e31d6f10e3b6f2f6af061e2bd4c4c4462d294efe73","signature":"f7f19a32de3a3ad31a7050dc80afe20164d3f16d2ea944192ad93b1bd5221bfc"},{"version":"4cedb5ce1bba4c1fc6f2f765e98cf54c5bf90789bd9f74fbb7859166120f5847","signature":"d013318cb51e48392ebba35b674c5e89430122f8f8507e33f86877240a292d4a"},{"version":"2d4f8a8fd5db331af1e1963f826427d9c6dbde7a9afe2ef604219f46eb0ffc55","signature":"d018409b5e03c6118a71bd9429eb5716071646a7eebbe1fc797e7f61e517fe22"},{"version":"61a5968277bc9ec2b72beb4bc2da7c5fa5808366f22265ea1d88426d694aa778","signature":"f8773af707e03dd98cd5bba224ee71e4bd352ad69ad5d3c878f485b037628b80"},{"version":"b8276c6f85ebda61487831ecd92a8498bd5c4f054f4dfb9cf2c8743ece4c56b1","signature":"316d331a9cb60ece959d46a64ae94a7116abfdcce401530b219a6bfae0b08aa0"},{"version":"a05a78fdc685906a03fbeda1be992036ef6b606ddd42e3b11b8d9025c5319773","signature":"1dab61c3fa314de48dc95a18ab2c61417e9fe066aea6c9a534255fa48de3357a"},{"version":"ccfe9ee9b703804016a09b7a708460fcdd34f9647e1a86de2a1bc02dc6937a3b","signature":"793cad7f7f0be4f4469b6a370fdb89fc8b19835e80a13113efee444617f650d6"},{"version":"14a2ecf56ec9ce9b49b81a56ca13c6a50d880a9e25d97621e8ebd570336f7772","signature":"042bec6c5e39d4582fcfa41d46f71906cfa7399dea3f104f6d35e33649f2ea5b"},{"version":"b7e549353a865d781a98bf988902da8fa7754e3f3387aae43d161a464420a58e","signature":"0d6b97647fbcc1af274577ccf985ec06965ef9ac342b3789156dc0eb1d84cc22"},{"version":"309ebd217636d68cf8784cbc3272c16fb94fb8e969e18b6fe88c35200340aef1","impliedFormat":1},{"version":"f987c74a4b4baf361afbf22a16d230ee490d662f9aa2066853bb7ebbb8611355","impliedFormat":1},{"version":"1ff91526fcdd634148c655ef86e912a273ce6a0239e2505701561f086678262b","impliedFormat":1},{"version":"bd93f6fc4da70275db4def32903eed2be03547a41857142df63ddfebb9a67bdf","impliedFormat":1},{"version":"8d67b13da77316a8a2fabc21d340866ddf8a4b99e76a6c951cc45189142df652","impliedFormat":1},{"version":"7952419455ca298776db0005b9b5b75571d484d526a29bfbdf041652213bce6f","impliedFormat":1},{"version":"21360500b20e0ec570f26f1cbb388c155ede043698970f316969840da4f16465","impliedFormat":1},{"version":"3a819c2928ee06bbcc84e2797fd3558ae2ebb7e0ed8d87f71732fb2e2acc87b4","impliedFormat":1},{"version":"1765e61249cb44bf5064d42bfa06956455bbc74dc05f074d5727e8962592c920","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"568b463d762d0df07ed10081293715069168ad7cf6308525a3bb93777b127845","impliedFormat":1},{"version":"6e5857f38aa297a859cab4ec891408659218a5a2610cd317b6dcbef9979459cc","impliedFormat":1},{"version":"add0ce7b77ba5b308492fa68f77f24d1ed1d9148534bdf05ac17c30763fc1a79","impliedFormat":1},{"version":"56ccc6238510b913f5e6c21afdc447632873f76748d0b30a87cb313b42f1c196","impliedFormat":1},{"version":"c1a2e05eb6d7ca8d7e4a7f4c93ccf0c2857e842a64c98eaee4d85841ee9855e6","impliedFormat":1},{"version":"85021a58f728318a9c83977a8a3a09196dcfc61345e0b8bbbb39422c1594f36b","impliedFormat":1},{"version":"d91805544905a40fbd639ba1b85f65dc13d6996a07034848d634aa9edb63479e","impliedFormat":1},{"version":"6042774c61ece4ba77b3bf375f15942eb054675b7957882a00c22c0e4fe5865c","impliedFormat":1},{"version":"5a3bd57ed7a9d9afef74c75f77fce79ba3c786401af9810cdf45907c4e93f30e","impliedFormat":1},{"version":"8610f5dc475d74c4b095aafa0c191548bfd43f65802e6da54b5e526202b8cfe0","impliedFormat":1},{"version":"7b9496d2e1664155c3c293e1fbbe2aba288614163c88cb81ed6061905924b8f9","impliedFormat":1},{"version":"e27451b24234dfed45f6cf22112a04955183a99c42a2691fb4936d63cfe42761","impliedFormat":1},{"version":"58d65a2803c3b6629b0e18c8bf1bc883a686fcf0333230dd0151ab6e85b74307","impliedFormat":1},{"version":"e818471014c77c103330aee11f00a7a00b37b35500b53ea6f337aefacd6174c9","impliedFormat":1},{"version":"2fbc91ba70096f93f57e22d1f0af22b707dbb3f9f5692cc4f1200861d3b75d88","impliedFormat":1},{"version":"29f823cbe0166e10e7176a94afe609a24b9e5af3858628c541ff8ce1727023cd","impliedFormat":1},{"version":"1026a02ec0694bc6aa393e4fcf39cc2fdb11702b85eeec2f02fe6f8efd1b5fa9","signature":"07d5b52bba05b29db0926a4001feb035ce13e255731e33675706fa8b31b302fb"},{"version":"985ad4e971494b61b4b12078891c0e941767b792c2d490df3b0f5acaf504b3c5","signature":"5341b1f1a8c5bfa1afc9220afb2bf59d416b6c36eda5459eab10844ff4733854"},{"version":"91b4ce96f6ad631a0a6920eb0ab928159ff01a439ae0e266ecdc9ea83126a195","impliedFormat":1},{"version":"88efe27bebddb62da9655a9f093e0c27719647e96747f16650489dc9671075d6","impliedFormat":1},{"version":"e348f128032c4807ad9359a1fff29fcbc5f551c81be807bfa86db5a45649b7ba","impliedFormat":1},{"version":"8ee6b07974528da39b7835556e12dd3198c0a13e4a9de321217cd2044f3de22e","impliedFormat":1},{"version":"5a38140438107de65fa204b3705b83529e225e1b01c68c73fb7fa4e88e5ddfa3","impliedFormat":1},{"version":"5f12132800d430adbe59b49c2c0354d85a71ada7d756e34250a655baa8ad4ae5","impliedFormat":1},{"version":"1996d1cd7d585a8359a35878f67abdd73cc35b1f675c9c6b147b202fdd8dfc3f","impliedFormat":1},{"version":"b16e757e4c35434065120a2b3bf13a518fc9e621dc9c2ed668f91635a9dc4e75","impliedFormat":1},{"version":"0b7ba8784d5de5560adeb015ca6d22d8a9d0920dcb16dd627b40010763f26d85","impliedFormat":1},{"version":"0377607549f9d921e43421851de61264443471afb1f0e86b847872e99bbe3ba0","impliedFormat":1},{"version":"4374cefdde5c6e9bad52b0436e887b8325b8f407c12035194ad02c28f1553a3a","impliedFormat":1},{"version":"9b70cad270593f676aecfe4d1611dc766464f0b8138527b0ebbf1ff773578d69","impliedFormat":1},{"version":"b4f85bfb7e831703ac81737361842f1ae4d924b42c5d1af2bff93cca521de4d1","impliedFormat":1},{"version":"5fea76008a2d537ca09d569ffae4e08b991b4a5ff90e9f4783bc983584454ede","impliedFormat":1},{"version":"21575cdeaca6a2c2a0beb8c2ecbc981d9deb95f879f82dc7d6e325fe8737b5ba","impliedFormat":1},{"version":"40ec58f0fadd0b3981b3d383e1c12fa0680115ae9f018387fc2cfc0bbcf23204","impliedFormat":1},{"version":"849b9e7283b7309a4556c9b90bb8e2dfc27751f157798065bbc513dcddb09a8c","impliedFormat":1},{"version":"10e109212c7be8a9f66e988e5d6c2a8900c9d14bf6beadf5fa70d32ada3425cf","impliedFormat":1},{"version":"2b821aeb31e690092f8eae671dd961a9d0fd598ff4883ce0a600c90e9e8fa716","impliedFormat":1},{"version":"26602933b613e4df3868a6c82e14fffa2393a08531cb333ed27b151923462981","impliedFormat":1},{"version":"f57a588d8f6b3ce5c8b494f2dc759a8885eaee18e80a4952df47de45403fedbe","impliedFormat":1},{"version":"34735727b3fe7a0ed0651a0f88d06449163d1989a2b2de7f047473adc7c1c383","impliedFormat":1},{"version":"a5b13abc88ab3186e713c445e59e2f6eee20c6167943517bc2f56985d89b8c55","impliedFormat":1},{"version":"c8a206a6ba4e32710ebb4a389187772423de0f4f6180b95a7ef1a5a1934c1be6","impliedFormat":1},{"version":"7ae65fe95b18205e241e6695cb2c61c0828d660aca7d08f68781b439a800e6b8","impliedFormat":1},{"version":"c2c8c166199d3a7bd093152437d1f6399d05e458a9ca9364456feecba920cda4","impliedFormat":1},{"version":"369b7270eeeb37982203b2cb18c7302947b89bf5818c1d3d2e95a0418f02b74e","impliedFormat":1},{"version":"94f95d223e2783b0aef4d15d7f6990a6a550fe17d099c501395f690337f7105e","impliedFormat":1},{"version":"039bd8d1e0d151570b66e75ee152877fb0e2f42eca43718632ac195e6884be34","impliedFormat":1},{"version":"9e615a787ac4628fe5bcf3f7b2edf1d487422945a5ce1826024cba04ee41daac","impliedFormat":1},{"version":"5f200be1d6585239093ed367e7a77a5400c76c80a00309ba9b4fc2bb5add9899","impliedFormat":1},{"version":"54e8e74c989105b68db60748270d50ca4330852a490b7c21098876cd6c06ad49","signature":"e8e40e8d9fe75ac0e61a3239829189338d2e18f682afc5e85d641ca6c864993b"},{"version":"4ed810e854887314758640210a5e1f1e3a12ce6016fc00f463f3cbe61772ed10","signature":"768ac3f70eaa70f9bb9388c6742bd67c913045f859b883ed047b2e542f595197"},{"version":"c3d3e266a1712e0038230faf4028fe64d425878f1316b4a04ea24375711ba4e1","signature":"9fd0548e2e0ae45863a450e49f0c5cca978f77096808f9d73ac8b1ef96e0756f"},{"version":"260484c4181267c0d8b95600e781dd1e67027a7673731a20574bb4e49ad13a4f","signature":"c33e556355e91be7918a3c88e00170baa218a85820cad9adbf7cf2fdd4adf5b3"},{"version":"fdbfae7207403251e38517fd91fdffb35e8f7d3941e58ad3515c0005fd53298e","signature":"04088483c561f4acfb8e34ab837a6daf70ccd6e93b71cd9f5f78919c8e41aa9b"},{"version":"9a0ffa4f6d723a51f4371965f906d5f39e97ec80413e9ecabed43e66f3d5cc5c","signature":"089acd7391fe8585299e7e29f6f0c4c8185cf519f805163a0d2fc8f6aa750031"},{"version":"26e21207904a5a08aeb95391f76405a89a388feeaa1e79a3cd250d4997c6a113","signature":"ed4d781d8e359500366f18b8f0ba478f8a89aeb6dd5b75120bb2ee0523257511"},{"version":"b3391ca95c77cae8bfb71c36524937023b885fddc5d7bf52b0b554f3f2e9df55","signature":"e6702e72e8db4ac9781662049c1cba82f6859b62d3c2e03e60fa5f35eb97c95a"},{"version":"c10e12f0eea81257155dd9b9c1c884c3ec172c7dd39fad2b14c8466fb0de2eb8","signature":"9fc9e5682163a9f5687f34a81c45be9dfe418a49843f2ec91013cda2ef69c884"},{"version":"77a3b3d312d7db0df5572cf558bed028a494cce6fe2024dc72d11772b28c96f1","signature":"c27309f8bdf5b2ee37592b8641bf4e1127a61f728215c230b05d8273dec078f7"},{"version":"57ca3d54dcb1d10d3b152460d7f1a47664c211699876080ccdb284a944b9bd4c","signature":"64f679f491ce72393557a76e2f9003aa25bf6e923bc2afbe964167b49772d237"},{"version":"d28d546a6c281eabdf55e7d27dc6ed6624da2999d305041ff1f19f170b9dec1d","signature":"146d15545dd67176ce34e11b7dfbd6d05ed485a9486241c520c4bb9eb631a8c2"},{"version":"31a9984b9580e2588a5edae451c6abbada4081c72c0e8eed2cbf09e47bc886f3","signature":"cc44894b562d47c8570d914ef3722016fb0bc4ebaed5036411a503e606f5a945"},{"version":"1febcd9ff659d6113c5e9a68cfb32e47555fffb2799be52430af08ded21ff84d","signature":"fdffd40e244e33d72848611ab2d1e6fda58c17597eea12719d7d2990b057b3d0"},{"version":"7983641709059d23a092a9282d84aa0561c299f34524397e2486b9369df7746b","signature":"3723342edc83c5309506073f6c0231da3b44ebaf9d57ff80b817d29655ecd33e"},{"version":"053a7a1a336d0882da361b3c63b7b48ae4bf284ae7bb0fa3b5c66f2174625413","signature":"d11c33d82518e60e038f5993fe8dc94b15fc2e6feead064782042369b812e74e"},{"version":"cfbe250c72daafde65b81a94d66b65b2ddc9a1d4a6a8a0eb4cb1232585e29892","signature":"7f5929c9df2d83e29fb75f2d9959c3195425bfa56e341df1c46dfbed4d774717"},{"version":"37fdea562c838a09547d37927c74eeaac84cac0b07a48ae62e45c4f193d3f1d2","signature":"5eb024f17d5b963ed6f7f8f618c6b8539e73e229bc069b6525d67407fa70f56f"},{"version":"7546bc598f1133279d9e7e601358952f109021559fbca87d16933a6188e0e6e3","signature":"aa414463a09894c59bd1cf68288fed941b0f53ee86586db0b35908b1b023bf12"},{"version":"c1f887932e7b4c903a217018a90da79d09b84e40de2fd7efac3eb9439ca72702","signature":"b51a28810590d2e1702f7b2f87379f777cbe22fae892b5101c09d1b87b492bb3"},{"version":"d4c16375decc58fc500aafca0793e6f4f89efc6173f9714112ce7ad3c891d85d","signature":"97e8b5455bb1a3c1a0fb8b2234bd5d71deb08e860406d5f8f01b93c8c2c27e98"},{"version":"f8a1781244d0365c586fd2836a6489937db097f699f0afe255c14f2118ead13d","signature":"82ea000610fcca063cd4626d04ca441f65445309fc9f908330b6b91cdd89328f"},"8e0022d7b3cec030a50a6ca8ba96dc766b51cc8bbc196cebe4ff95a8d8c87c7c",{"version":"f4d1e2bbf780ffd1f319e093a1d8dc1c973825bde6a8107ae780a420759d3877","signature":"c3a82e4f373bf68e45b8255bc2ddbc5da1c0f019b025ee8feb1b9021c7e2ee8a"},{"version":"8d5029d35ffaa540d18372a88b78ff0adb9fbb577751a6d389f3f23a075c450b","signature":"a1f8bd8ffa9d799e74910903d63a9a344ec3bd8135b5f5ab15e20267e37b5017"},"26b91863b4e8bde9d6d30b1a5d75e94771fbc9598f6ecc2464dac58b3152814e",{"version":"8329a0b50f818665f1aca05ab93c16b103178b463f2949234ee4416bbc7d3fe2","signature":"1f8bb24b9445ba23ba7975442082768beedd19cb8e032b538ee8714acdd20108"},"31cb925a751b4b3364865dc271f07f27302181650c896859ca5aed7c0791e5dc","7fe0b310644a21bbe1b464223a79d2f653e8d74d1c09f4b15c2905fa045e5174",{"version":"6aa2859da46f726a22040725e684ea964d7469a6b26f1c0a6634bb65e79062b0","impliedFormat":99},{"version":"2f304078088f2f4dad8c89966a7abb2f5989e450ca36bbba6b6ca175b7cd1733","signature":"fa01815d97da0e20aa59b46fb1e69096b102d91a5a471ddcffa4e7105a3b23ce"},"26bbd7def47a42b6058e8b14e30412f5f6c7e0caa7683d048d655385ff8c9ed3","3c4e2eba32baf7aab362d75ac4e11e354e070717af3918c53d05d80403efe2f3","41dcebe1bbfa0adec2d4629fe1bab2d61add18c190273401ce93566e0263b755","d584fca8405cf26d223044581e34e96791ed1528a02709c548a28e3951c0db09","76bc198b46ad2065aa23793d70e48ffd6b82ee73abee6f102e4f9aa5f9287a09","0f8343707440e6c892d286341701d86848a79dc764a220a56ec06f9718348b53","249fc8f4b084ba85841b379a01d86e85a431b627dd6b98f771033613977fa722","89b0676baf5a061c8d5ce1e1d80e3b02fa4c027ca3c577d49d82dada75402e48","18874081455df78221becbde75abf5caef957ec17aaa456072b2665adfa96713",{"version":"04e74bcb4dcffb60f68e28996a310f39576386db51ee93f1a2a52efad9e0cc5a","signature":"f15525c528f2fb2d83814b552f1f477d8d44572672982ed99da742bcd9b77646"},"958d8fa5097c7cdd2697e4d0f8f34f1caa06241265badb26851e6691b4bbe5d9",{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"dfcf16e716338e9fe8cf790ac7756f61c85b83b699861df970661e97bf482692","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"2a00cea77767cb26393ee6f972fd32941249a0d65b246bfcb20a780a2b919a21","impliedFormat":99},{"version":"98007168d58f43df4d2428e25ba09e0ee7ace257b3aa1a48fb53cdd33e428c7f","signature":"8aed813c358a5eb08feb1e4808c7f4a6c12b247ad6b2b16f17cd04f94992cf28"},{"version":"8dedd59e5ce4288bb28f7b50cc8716d9b23487e08a13bc399bb53381de9fb786","signature":"daa157691b1d671ea52f53a1128f2c339e01062d2d59c8a11f2e6b8f245cc922"},"db5f8f5659b4d5d2d19ac7cda263927b01525b1d4c39d7b72ddb53cf58df71c9","a52624854d9bdf9935a711dfd283282846eee4a7a3f52e176591fdcc51da7171","9b663cff1dfbd10aa9fa5543776c731e8b96872a114291d3418ceaad8b14ae33","b9107eccee190d80e37633f8b9414394be98ee0a9ef556df3f39fdf71a291af2",{"version":"4446850b5665c2f5bc7c4363a6e42256a47a3df4620da09ffd1f84d3b8293f10","signature":"2da657bfb326db428e9d1328473b688da6648efedc0bfdd528718109c202981a"},{"version":"d1ff367c377396feb0ef5b12f1a404a930dcd0f7082bcf8d9276a802d94ef3ab","signature":"f00cb3cf2eb0b87c43e88211235cec90902469631c81f525038b66203f083209"},{"version":"48b94f3b652c68c0f427d19773e6460c6176ee95f0ea9864cb03e8cc9176acf8","signature":"91f51641daa8dadd247163be7a1e293765df88595205afaa7d2678217491783f"},{"version":"e3507ff969a7c1c9d55e0e6a7986d863433ac6fab17e27f5fa6c8d0fd79c15be","impliedFormat":99},{"version":"8bb642bc24d7a21e67124613f77174e377b053b4e50f08d3bb8b4b71c30da185","impliedFormat":99},{"version":"c043623180122dddecf5565e0809ea90426d6fc370454cd2ba1ab99ca3398248","impliedFormat":99},{"version":"70f20697bc3ed03af85920db61fb1e4388fffa37cd2e0c0d937e7608f5608bd1","impliedFormat":99},{"version":"5e35a2a3f0b62ee763fd1d1f13cdec015ea10fb1ed7a670989b1ba49b37ad287","impliedFormat":1},{"version":"b3b5aca751100320745c8bfd826202aed7d753d336448ce2265b9470dfa8a298","impliedFormat":1},{"version":"5fa35c6051059d5ed57cbda5479b593cec15d5405229542042bd583c1e680fb4","impliedFormat":1},{"version":"7df3932c1b8816845e1774538c4e921e196d396b3419e2e18bc973079b4064a3","impliedFormat":1},{"version":"c8a7131a27d7892f009ab03d78dc113582f819c429af2064280bec83c2e7c599","impliedFormat":1},{"version":"19629032a378771a07e93c0ab8253b92cb83e786446f1c0aed01d8f9b96a3fb6","impliedFormat":1},{"version":"fd4b51f120103d53cc03eea9d98d6a1c7e6c07f04847c0658ec925ceeb7667aa","impliedFormat":1},{"version":"53bacb19d6714c3ea41bebf01a34d35468a0ac0c9331d2ffdc411ce452444a2f","impliedFormat":1},{"version":"e2ce339ecc8f65810eda93bb801eb9278f616b653f5974135908df2c30acc5ae","impliedFormat":1},{"version":"234058398306e26bc917e6efba8fb26c9d9f2cfdfbaa17abfcb11138847de081","impliedFormat":1},{"version":"b3ff9aff54c18834bce9690184e69fd44fd5d57273a98a47fbf518b68cc4ec60","impliedFormat":1},{"version":"e6cfcf171b5f7ec0cb620eee4669739ad2711597d0ff7fdb79298dfc1118e66a","impliedFormat":1},{"version":"3dc40ead9c5ac3f164af434069561d6c660e64f77c71ab6ad405c5edc0724a94","impliedFormat":1},{"version":"d5fb34e3200ce13445c603012c0dfbd116317f8d5fef294e11f49d00a859a3d0","impliedFormat":1},{"version":"58fc843cdfd37a8b1ae2cbf3d6d3718d41cdafcbbf17e228bd6a7762a7235bf0","impliedFormat":1},{"version":"a4d0945318f81b27529abcae16d65612decf4164021a0d4d2ec19fbfcbaf1555","impliedFormat":1},{"version":"fbe57f37a07a627af9ae5922c86132677e58689427cc748866a549ef3862f859","impliedFormat":1},{"version":"8df750d51d498be760d538ac9818c7aebea597f21d4937a65fb2ebedd8a976e7","impliedFormat":1},{"version":"5b9c5efb469020fd6a8c6cb8c4b378ef3dc46ad97938ac900882f1d5f237bc91","impliedFormat":1},{"version":"83dc862cd9b7b1a929bcc03e9bbc8690cebc7e29b1edfa263f6fd11b737f19df","impliedFormat":1},{"version":"fffacebbcc213081096e101e64402c9fb772c5b4b36ad5e3d675e8d487c9e8af","impliedFormat":1},{"version":"1b243b5a51dff2bf70b7a6ce368fe7ff845c300027404b5a41a87ce5490cdad0","impliedFormat":1},{"version":"dfb119c12d7d177eb47b98c011677ca852dff82ddbe40ea571e31e04d2b84278","impliedFormat":1},{"version":"e0b50044596bf7b246a9ad7b804cc5ab521f02e89460a017981384895a468f23","impliedFormat":1},{"version":"b303a99933b69d9d6589ac24f215e5d987933782244251a10e62534f08852d94","impliedFormat":1},{"version":"e052b679185d44460040d5ce3d703d503e5f7108cd4e9d057323f307c6c0e42e","impliedFormat":1},{"version":"ddb79ad4350198a188ad3230d2646b4c67467941ddf4022ed01e4511a56d2cd9","impliedFormat":1},{"version":"8b3de2f727cfd97055765350c2e4d50ea322cabb517ff7aa3fa0ad74aab4826e","impliedFormat":1},{"version":"b3e584a57553f573aa01b34bf0d08c4dfefb2b9ede471c70d85207131f0f742f","impliedFormat":1},{"version":"23a24f7efe3c9186a1b05cd9a64a300818dd0716ffbd522d27178ec13dc1f620","impliedFormat":1},{"version":"6849f3dd56770a08b9783d61e3ba6e2d0ba82850a20ae97e1bdcaeb231d2f7fc","impliedFormat":1},{"version":"6fb23beb59f1f5c8dc97bfc012d5edac81ffca1c1b83a91381b4e130e7ce24f3","impliedFormat":1},{"version":"bc759b587b3e7213fc658fe78dbaf7b0e7c0a85f37626823b4bbef063759c406","impliedFormat":1},{"version":"04ed59801192608de22461e38b9f2e300953f1d6d6c05332f19e78e668d6a843","impliedFormat":1},{"version":"bf5cfc96bacabfe71962c32755df63ac499f732571368db3bdd7e144336c50f7","impliedFormat":1},{"version":"4c10770eca2ae9c1d5c97dad5c715b0c65def8699066231851a69fa58aaab3bf","impliedFormat":1},{"version":"c7e7d48913bfa205453911f699307e7ce630deb3c3e68326377bc2ba20abb1f9","impliedFormat":1},{"version":"4b78505d4f7ba7a80b24dae9b9808c2ec3ecb6171af03a4b86a7a0855d7a80c1","impliedFormat":1},{"version":"d09d8ac8da326eb4cf708d3a3937266180fe28e91c3a26e47218425b2ec1851d","impliedFormat":1},{"version":"50c0c2b5e76e48e1168355e3622ca22e939c09867e3deb9b7a260d5f4e8d890c","impliedFormat":1},{"version":"66491ea35e30cc8c11169e5580aef31e30fdf20b39bc22e0847c2c7994e2071b","impliedFormat":1},{"version":"35680fb7f25a165e31e93ea22d106220db4450b1270a135b73f731b66b3d4539","impliedFormat":1},{"version":"5865007a5331be0842d8f0aace163deda0a0672e95389fe6f87b61988478a626","impliedFormat":1},{"version":"dddc865f251a4993b9e23494a9ae0fb58997e0941b1ec774490a272d5a0b29bd","impliedFormat":1},{"version":"76d1f106ef20648708a7d410326b8ad90fc6f7d4cdf0e262edd6bd150676151b","impliedFormat":1},{"version":"6e974c9f7e02b1f1b7c9538619fe25d9d23e4eb5df3102f62f3bb0cb3d735d1a","impliedFormat":1},{"version":"18f3835257e2f87f8dc995c566217c5434d9bc14a6d18e7ca0e2afbfc2f1eca8","impliedFormat":1},{"version":"69055f4f0b1b2df9f0ca89231075c0578975518543100582dd37adb956ad6135","impliedFormat":1},{"version":"c3f85a0f71b64d78e7dfb27a12d10b0cd621745f40752b8e9fa61a7099d4290e","impliedFormat":1},{"version":"0b4b2424b5d19bbac7e7ad9366419746fff0f70001c1867b04440d0031b26991","impliedFormat":1},{"version":"e6d999c047721b80fc44a025370dbc02022390bfcf3c1e05cd200c53720c3f16","impliedFormat":1},{"version":"4fd695c068c325f2eb6effd7a2ed607d04f4ed24b1f7cc006b8325b3eb5bd595","impliedFormat":1},{"version":"c18fb9b8d4a7f41ae537512368ec9028d50b17e33e26c99f864912824b6e8c30","impliedFormat":1},{"version":"2b214fb1c919b0483175967f9cf0809e0ac595a7be41ba5566be27ce3d66cf86","impliedFormat":1},{"version":"ff8ece28a240cb8a29342a8c54efdaf124f93301081afa047bd1e7f6ec2a79e3","impliedFormat":1},{"version":"9b923be7ef4337bbddbd1713b13cf81da9a955034bdf657bb9e60a8fc9b20ac5","affectsGlobalScope":true,"impliedFormat":1},{"version":"527668d62da5909154a74b74a7a9ae59c41ab4a70da76c2f476765308efafb0f","impliedFormat":1},{"version":"e2974b2b0a7ba6384f5f3338d2a6a70170c3002112d6e05ce593d966100bf232","impliedFormat":1},{"version":"cc3738598b5fe875e341f701824403b3cac48c50472c72423d3e236b610fa977","impliedFormat":1},{"version":"f06e49e80942ebd4f352b1d52d51e749cb943e5b7e368cdf0ce15a169cfad5d0","impliedFormat":99},{"version":"adcbd1ed0d1621b7b2998cc3639871b57d85a3f862759d81c8634fbb6f3ec260","impliedFormat":99},{"version":"c982042c9614e12edd22a8ec0ba55c52fb31b41a513e841a0f3916fea6f775ca","impliedFormat":99},{"version":"28004f9370a7177104fe5c71381f4d2ddf8099066ba15ad0264df14135f0210a","impliedFormat":99},{"version":"0d85481bf9d4418ad633806d8d909777749291164161e87d3f76fb68ab1ae4b1","impliedFormat":99},{"version":"26474a5870247854706ee1a1b53846c464fa46d4f0fce6feca43516c6a565ece","impliedFormat":99},{"version":"499060fff17e6127887065c69309b9785808229fa4851185762b434fd191eb8f","impliedFormat":99},{"version":"e8b61ed76ce071a18c16b3d5145c9ec24a79afa4a40e4e70482d420988ad2e92","impliedFormat":99},{"version":"959c15065a76d4dc5e77e5c83dab8bcd52ebaa5779eb4d42fb43a5134c219eca","impliedFormat":99},{"version":"6aba2b87d07562e15164415aeb5ef55e544cfc4ead91c18982e0c5b70739c120","impliedFormat":99},{"version":"876324641782ef0d4123c39ce5b4fe59ddf3dcd8ef747bc06bd935aedf0a71c6","impliedFormat":99},{"version":"0716a38be84ad12588a2ffeb66977b960b6f9ec477473063b61b7fab971bbe4e","impliedFormat":99},{"version":"029fc7882219b11a8d7f0b64a51ecc6cceff45813fb0d5daf793c503a20dffa7","impliedFormat":99},{"version":"5cfb2066d3fe03aa5d6ffad84629bcb1eb4fe7cad46f874afca80aa459962b75","impliedFormat":99},{"version":"0a1b0a946c2dc3dbc3f7b41fab8ca5a3bb5f21fc3965dc07d1cb5af831a962d3","impliedFormat":99},{"version":"0e1a03168fbe0d48c1a558ce495ea48c922f9c2c98658092ef8361bb8c40536a","impliedFormat":99},{"version":"1204aa56ffbdf67afe38cd279d602ff1033fe9dc2110fc8fc219f1deb4b18a5e","impliedFormat":99},{"version":"922f879e741bb05195e598b51a58e3784f34761ee4d92f2f470f57740ffa1b7b","impliedFormat":99},{"version":"a06db219f83fd299973856c648293bcfca1f606a2617b7750f75b13dd28ca5fd","impliedFormat":99},{"version":"8832937a4f608e96d8c7b53fd5c040fd1e2be78dea6ca926b9c16e235f114749","impliedFormat":99},{"version":"60fa62255c9a3fc917f4be2d8c23ded1f3e919f68db44af67f8c67b46014663a","impliedFormat":99},{"version":"ebd64fdcbf908c363ab65ccb1ad9f26d82cd2bbb910fee5a955f3b75f937b1d2","impliedFormat":99},{"version":"608c0d45e9440b26e61a906bcd32ca23db396fa32aa29087db107bee281d70bf","impliedFormat":99},{"version":"c57ff70bc0ae1a2abe4f1a4c8fc8708f7cd99d0de97fac042e0ba9f4970c35db","impliedFormat":99},{"version":"cf5007ed1f1bdd4d9c696370c6fa698eddef590768bbb9807c7b9cb4000a9ec7","impliedFormat":99},{"version":"b96853f733fed9aa8ad28d397e1ec843792749dd8432e7f764edcb5231ec4160","impliedFormat":99},{"version":"6ee0d36f09cff8a99010c8761003a83b910149e5d7b39656f889b2bbbabe0f27","impliedFormat":99},{"version":"b9f6ae525124fa2244c7e5ae3d788d787db47c4dab1beda7809cfb6c47f74968","impliedFormat":99},{"version":"a74c7a2244c60699441eb66577f230112eb56235a0fd7b26451ffe03c999991d","impliedFormat":99},{"version":"a1fc2559d90de9e703fab40ed46ff05a402113d164892c3c4ca192102f136c99","impliedFormat":99},{"version":"514167c3cc3640146a0ede53e59dc82c1d27ad1bc1e134912a0ea2cff69f997c","impliedFormat":99},{"version":"10ce8a11a9beb91431a0246977d0c9342c9f530b6ddaf756a0ad6fef22818b9d","impliedFormat":99},{"version":"269ed3176766758542995bfab9612b921bb47c3b1efd382b3ec843d0e2dc147d","impliedFormat":99},{"version":"f3ec93a448c4bf491bd372962f4c9a402ba97a917ce905ac0251f16c2e03fb43","impliedFormat":99},{"version":"3c7869711e28e33bb715dedb6879707cb54bb91b0ea9e54c9e308ed23be6b8b4","impliedFormat":99},{"version":"abbd33f1c632b4e592fde62769716a5134831f960832d7007a6491e73e4ae109","impliedFormat":99},{"version":"f88a59d7650984e794b40b34303dcedc1c3802acf21429f110c832fedb529dc0","impliedFormat":99},{"version":"2e7ef180b0a117ec2edfc2e349b4ccea4ad63114ea41b0262aa3a6e01cb223f0","impliedFormat":99},{"version":"9e909c7914b218861b219760732ae7a7a880b7d8e5d4feff64eef921ca5efaae","impliedFormat":99},{"version":"de94ac03f309847b4febab46e6a7de3ed68cf6d3a3faf50823def5d1309cbf47","impliedFormat":99},{"version":"97eba2d9706d755314bb85231c44219b707f84209032197255c4c11c6acbfd3c","signature":"496cd22bb4f82c69d05d88ac924b20c9777a3232348707278cf5375b7a1ab576"},{"version":"ae4eef1bf8c13f009f82147f6a2763f2c7472529c7f7fb739f8d45c7bff03a47","signature":"0bb5669ada7a7c579244609dbed2c0db86aebc5c8b89bed00f121775ab60cc49"},{"version":"91f6bdd3a9e945fa50d6a3c005a07b6f15de69415ead01293a039f4603b7523d","signature":"ed59bf3031f5aa24f0ceda91d6c5c9ea5e094f196ba2359409722b13e88de6f8"},{"version":"cfd9b75da29a6a5ba78c0aa4ec57b9bc5e7a55d1acf7de095ed91f662cdf2579","signature":"0c5c3f2215f494cc70301fb873c29441118a9232a5d14eaf6f67ed0dc2317885"},{"version":"473f734af60adb3d6962b0d457063f709fd4570d7c18ed09b50efee7ff9615ce","signature":"b098e49412a79e18117a33c5ebf61cb00b5ab79a0b296528fe7ad705b9bdd013"},{"version":"7fc745acebbee6e62e1d9498a48328d2d8b730a0e4cee78a6349a1be43be7d80","signature":"bd2ee593357e30f039c0a1e7e6901eab64ce342549240e0724ff461e11061584"},{"version":"f74bec68dd458976ea06f05ebdb4cc5b0e42e5242e5361edf0e5ec6e25dd717b","signature":"709605705d4907db12fa43a49e08de13bc875b40e469640cfca3ab72721c87b4"},{"version":"4d7d964609a07368d076ce943b07106c5ebee8138c307d3273ba1cf3a0c3c751","impliedFormat":99},{"version":"0e48c1354203ba2ca366b62a0f22fec9e10c251d9d6420c6d435da1d079e6126","impliedFormat":99},{"version":"0662a451f0584bb3026340c3661c3a89774182976cd373eca502a1d3b5c7b580","impliedFormat":99},{"version":"68219da40672405b0632a0a544d1319b5bfe3fa0401f1283d4c9854b0cc114ce","impliedFormat":99},{"version":"ee40ce45ec7c5888f0c1042abc595649d08f51e509af2c78c77403f1db75482a","impliedFormat":99},{"version":"7841bca23a8296afd82fd036fc8d3b1fed3c1e0c82ee614254693ccd47e916fc","impliedFormat":99},{"version":"b09c433ed46538d0dc7e40f49a9bf532712221219761a0f389e60349c59b3932","impliedFormat":99},{"version":"2fe97c700340d65f35f1bf31a74e2a530d04f47fc2ce7423d4880216452ab085","impliedFormat":99},{"version":"50bc55fc955fa799a4a1a11c3484077f06cc87033c68f5da6466b520876cb12f","impliedFormat":99},{"version":"22973bc5e4a4013061472e4bf3355fb6bb52cc5dfb42406d0aef0357a1fb3735","signature":"5b053d96ccc6391f56b1067a3cfbf5242924a0d3b023d731e16e0590595b24ff"},{"version":"f97faedb195315ae8f6c7edc1c895e465fa4613ccf35d5a850b77309abb2f880","signature":"29b81b6565ea28b26b07a2397a01c385b9da74235f1a867a33121354ba494f6f"},{"version":"c0479252952435fc8723ff7c46ed0ee950c4df55120837b27388ec17aaebf48c","signature":"57588e86a3dc1e1d63c6677ea4f3ac4a3529bacb3ba2eac4c4e9db5d174ac500"},{"version":"0b538297db0f7f6d639363e6e05d44e838d6c22b54519b0f794b642dc4c7c8c5","signature":"38b417f10aa857d5069b795c8b22e2952d287d22434596aa41cdec514ef8a073"},{"version":"e2ab89665b8d3a6097916601f56f8d8af1a8491ff63badd7eac3343d74979e0c","signature":"7184a811eca741a0b632eaec8dc054be85644743c22d84c0d76c6ce766a8f003"},{"version":"591b5d40d84be86d4603185460d15b35bb362bae84c46d55b511e54017d4ffe1","signature":"4e6c38cb8996d9c28afbf8c421f736c09b408079582482f3e65a0cba51d70d94"},{"version":"375700e065dd9948ca1ebb6793f62c18890f37bcb42ab757d73df6623dd903d9","impliedFormat":99},{"version":"4781142e27cfd19d75a2c0ee432826153fcdf670bdc52631a6078330c9133e6f","impliedFormat":99},{"version":"93515fa80b2295b33e3e38c3f835f1f602e1a1899b2cfa4215f11600478379c2","impliedFormat":99},{"version":"94896adfc3bcc06c707d9b3e4b3d0001d9ea39cd4ae805082a14491efbed6316","signature":"ee7a7d891dd0b0005b4dc9a7bcdb89e4300038f59ef33866731f1ae221e6f8ee"},{"version":"57aa303c296ff62f609c5a52ec5afbeb02cac7b769cbebb46be7b576e1ab3ddf","signature":"db56e1285f6ec596827631cbe48c095bbea2e8fdc3f901db2b21a51c08e60ce3"},{"version":"c13bc0c7c75bc996a9157a6319e3d007996d1389efc23e1417f0f42a3faf6045","impliedFormat":99},{"version":"f665b7400ea6d37fcc8bf8adb593cbc976926c13a616bc1bd6de8d8edda9f2b8","impliedFormat":99},{"version":"5c1255a52052237b712730bd0da805b0a708262909e500479a321688c1d6d197","impliedFormat":99},{"version":"b5a7c01a7b037ba33207ea7f1cf4c1fe65cfdde4ef83a8e1deb03f777e7ef2e0","signature":"7daf2126a5d8bdf4ef07669a69b291a46b76739e1085849baedcb94ef341e814"},{"version":"aa7a5425ff1fe64b035d4ac9c77ca1faaf410c4de7200be4cd112d53df6c1af9","signature":"9bc80befce6a60cc78a9eff1499995de23613754ca5339d92024a1b10a3ae338"},{"version":"703473df5a12fd91f969f58394059f512dd70d88c2eed68583a77212968094b6","signature":"048ef49f923e7ad7b06ffe95ceb407238a4554bf49dc36eaf1a76eaf75535edb"},{"version":"8309c9db65b1f3ecf337e2d73e26d137ef711d951f2a93643a7bcdcd7a979a19","signature":"658714ef591d2d51abab7172f2dcbddac9cfcd3e7c9ef6ba4f0a85248f6850df"},{"version":"4902f89e2c23ae6814a3818577c8602e2211912c1c74219846dd0d7709f3c328","signature":"5b4567b44b055c85ac88531073f1550a5465ea96dd82620c7b756ac0a8552ed3"},{"version":"228b0e18d6c64b67f83ecf29d0ac5394a4cebc2bdd7a9d5ee12f5dcff6a95805","signature":"b2c7cf7f304f6ebfea4dda1e9c526a79a591fc8d3bd003af083384025da649b1"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"89783bd45ab35df55203b522f8271500189c3526976af533a599a86caaf31362","impliedFormat":99},{"version":"26e6c521a290630ea31f0205a46a87cab35faac96e2b30606f37bae7bcda4f9d","impliedFormat":99},{"version":"798b5337dc147d88c65de01f7221e0bfa04272968a1fce6acc1ec0bef7d9ddb9","signature":"0ae95632387b568863f5432688f3d5b538edb7f0b60efa3e403667dbf4a6f509"},{"version":"163c2623809f0fce501b02fe357fbfdcd7139d1328c10f9be20104ef26a1dcb0","signature":"3c08f6713620a686351d4a0751134e94e3f78f66642b7c22f8afffd2c523b703"},{"version":"950bea01f2a3f9ecad239726a080cad2b9d47153849a4d14abb905f0f60d8292","signature":"0a7fd7460c25272fe93528407b12b7e1874a657e9c3a3070d6e37864f095b6a0"},"cb1149dc9b8b49da93176fad7a5a04f97fd7814b92c00b2608fd06c9142f76af","9df2681521a3c1735b5f226ef0ea22506fad3fe592a0bd5822154b138ae9b4e1",{"version":"d41a68d60235fc1ad32ebf8eb0801bda0dbdf57992963503cfeace5c1f09bac9","signature":"7feccbfe0b4f3bbc1845f7982d68ce418f78481d0551310b84f96b7f9b2054b2"},{"version":"abdf38defffa91a0b8d26bd44033f148339036d56a4d1b8c83bd84cbd9689376","signature":"85580d3804f4284f0c83977fcf42034a794963b26f5ce929a15d84dec78fa1ba"},{"version":"b67e583128915dd73859e4e8f1e0df85f461ba3cc6997fb9b9af2402e4a5f431","signature":"e48edb6bb46fd51d556c424443612274746402c087eb39181775343d8e823618"},{"version":"f3a959e927e7f615371474ae959d900f19f03586a582e4e7dc9d35055cd06ac8","signature":"817ea241dbf951a15227290a558a5f75568c2baa3ab780809dc77e3cc45fda07"},{"version":"cb8f71eb51a21690b5cd207c0624b2e791de4c86617ec4f77edbc43738821211","signature":"b12a354249fdbc0ade9ef40f09af35ac2a6eea05cfc4c0410595379f518bdef4"},{"version":"742246c4523cfe0256bb85e503d55afa7411d5dd0792e8ff69bfdf8afe1cec76","signature":"d4ae819a0e3b5a81e1da7c92cab87f3d0724595e70b05ab6c431d93e08ac6361"},{"version":"c1424847f8905ee22d15ce094f27ac27a0b33801fec847dbaf9b1239a5c2abd9","impliedFormat":1},{"version":"222ca30f5d8caedf7c691abb6ec681b4fe9d6a6008418f0c5f27ca64ee30e536","impliedFormat":1},{"version":"503c2d4238fb9e95fdfe87cab5e1683a673515e76516514ba1c571697a8d9655","impliedFormat":1},{"version":"2c378d9368abcd2eba8c29b294d40909845f68557bc0b38117e4f04fc56e5f9c","impliedFormat":1},{"version":"bb220eaac1677e2ad82ac4e7fd3e609a0c7b6f2d6d9c673a35068c97f9fcd5cd","affectsGlobalScope":true,"impliedFormat":1},{"version":"c60b14c297cc569c648ddaea70bc1540903b7f4da416edd46687e88a543515a1","impliedFormat":1},{"version":"a43e9687b77e09d98cf9922bfe0910bb0ed7e5b910148c796e742764ce7dc773","impliedFormat":1},{"version":"faa03a3b555488b5ce533ce6b0cf46c75a7e1cd8f2af14211f5721ef6ea20c82","impliedFormat":1},{"version":"43c39d43de6c598e908401ed15ab7ba7d3e1b34460003025ea62ad48418dde98","impliedFormat":1},{"version":"80c3dbd0388dfa12adaab2ba562b961d79eabaa5f966dea4a59954effa7dbe8d","impliedFormat":1},{"version":"650c26b5a44787da1b03c89a3a17b2c6dc30c6f152c6314389298759e6a59275","impliedFormat":1},{"version":"e014c4f7e51d02f2aa47b21a45ab1313235283a07dc039dd2ab7a104f64da7f3","impliedFormat":1},{"version":"63b3480521274886ca85e33a7dadbd5052d3b5f3313800355a42428ea0361a96","impliedFormat":1},{"version":"f734b58ea162765ff4d4a36f671ee06da898921e985a2064510f4925ec1ed062","affectsGlobalScope":true,"impliedFormat":1},{"version":"acb93abc527fa52eb2adc5602a7c3c0949861f8e4317a187bb5c3372f872eff4","impliedFormat":1},{"version":"37f96daaddc2dd96712b2e86f3901f477ac01a5c2539b1bc07fd609d62039ee1","impliedFormat":1},{"version":"9c5c84c449a3d74e417343410ba9f1bd8bfeb32abd16945a1b3d0592ded31bc8","impliedFormat":1},{"version":"a7f09d2aaf994dbfd872eda4f2411d619217b04dbe0916202304e7a3d4b0f5f8","impliedFormat":1},{"version":"a1e2b9e55ddf6cfa9435f3a7026380749fda2f5a9f8dac57f4c5e1f40f53bf3c","impliedFormat":99},{"version":"fca68ac3b92725dbf3dac3f9fbc80775b66d2a9c642e75595a4a11a2095b3c9a","impliedFormat":1},{"version":"81c4a0e6de3d5674ec3a721e04b3eb3244180bda86a22c4185ecac0e3f051cd8","impliedFormat":1},{"version":"78d030052390a253a1ee7675591425671de366f6964130a8e148a2166d6fc452","impliedFormat":1},{"version":"223709d7c096b4e2bb00390775e43481426c370ac8e270de7e4c36d355fc8bc9","impliedFormat":1},{"version":"61a03761af9f60417c66882a48eb383957bda5987393d2f32e1ed104e8d48f15","impliedFormat":1},{"version":"2b8a883d217f55290af714b87ef738e32e0b99984b23b0f82a98caae362e7451","impliedFormat":1},{"version":"d5e806fbb24521445d9e5b11bc3fd626fdb2c0b11d3a8f96f9b68ea402cad9fa","impliedFormat":1},{"version":"7261cabedede09ebfd50e135af40be34f76fb9dbc617e129eaec21b00161ae86","impliedFormat":1},{"version":"ea554794a0d4136c5c6ea8f59ae894c3c0848b17848468a63ed5d3a307e148ae","impliedFormat":1},{"version":"26d9ea4d13529d0e6192db96841b264f9a0fc9236fe234d96cdf8e8141c24576","impliedFormat":1},{"version":"94c8c60f751015c8f38923e0d1ae32dd4780b572660123fa087b0cf9884a68a8","impliedFormat":1},{"version":"690c8311d7bcf6e2d2fb143335aebedc8025e9bbd5696da3d7fa35cf5ec5b6ac","impliedFormat":1},{"version":"685a189e1adddbdfd0eaee9f42df9e77e89fb60756305a398d8ee480148b6678","impliedFormat":1},{"version":"c5b47653a15ec7c0bde956e77e5ca103ddc180d40eb4b311e4a024ef7c668fb0","impliedFormat":1},{"version":"fb7e20b94d23d989fa7c7d20fccebef31c1ef2d3d9ca179cadba6516e4e918ad","impliedFormat":1},{"version":"8326f735a1f0d2b4ad20539cda4e0d2e7c5fc0b534e3c0d503d5ed20a5711009","impliedFormat":1},{"version":"8d720cd4ee809af1d81f4ce88f02168568d5fded574d89875afd8fe7afd9549e","impliedFormat":1},{"version":"df87c2628c5567fd71dc0b765c845b0cbfef61e7c2e56961ac527bfb615ea639","impliedFormat":1},{"version":"659a83f1dd901de4198c9c2aa70e4a46a9bd0c41ce8a42ee26f2dbff5e86b1f3","impliedFormat":1},{"version":"a66f3da7de689a5879af9501bbae12a28b42194e0a364afb7a6d395b3e3813c3","impliedFormat":1},{"version":"a0baa826317f013ecb3e451192a309b591f430432dddfec349fc61a11e9c44d4","impliedFormat":1},{"version":"953440f26228d2301293dbb5a71397b5508ba09f57c5dbcd33b16eca57076eb2","impliedFormat":1},{"version":"beb6995acedc0239d062124022004eb8341fa5eb62d9c867c1881c04f4233797","impliedFormat":1},{"version":"1b6358a3b261d9e6096154f9b5aecaddba845c95335d021e87a5626962092bd3","impliedFormat":1},{"version":"64aff4bce69cccfd193353af05e8b3ae3125c009969d2dda49072ec297e2fc82","impliedFormat":1},{"version":"cb4a9bad89a226da94b70cd0cca2010ffde636f34022bec7fc69caf9e6ad8e20","impliedFormat":1},{"version":"43587ce13d0b0bb9f6ee8363020d8521102381cefb4b650b1c4ae9ad56ed7e07","impliedFormat":1},{"version":"3f3526aea8d29f0c53f8fb99201c770c87c357b5e87349aca8494bfd0c145c26","impliedFormat":1},{"version":"e33bd2b4ebf93c3bb248d845e3751f5c31731268ce71bc38f99ec44e64daaab1","impliedFormat":1},{"version":"1801a58e8cbd538d216fbea6af3808bd2b25fa01cf8d52dba29b6b8ac93cb70c","impliedFormat":1},{"version":"4326dc453ff5bf36ad778e93b7021cdd9abcfc4efe75a5c04032324f404af558","impliedFormat":1},{"version":"9b597900f033ffe72808c6c39d62142c920499e51748a247d2f9dc16cdd3bcd5","impliedFormat":1},{"version":"64843c2f493a1ff3ef8cf8db3cff661598f13b6cb794675fc0b2af5fdb2f3116","impliedFormat":1},{"version":"0e447b14e81b5b3e5d83cbea58b734850f78fb883f810e46d3dedba1a5124658","impliedFormat":1},{"version":"bcd9c89a593fc73c694bb5e06c8bf7c6bdda0ac491195ef364d9dac5f7db0f03","impliedFormat":1},{"version":"929939785efdef0b6781b7d3a7098238ea3af41be010f18d6627fd061b6c9edf","impliedFormat":1},{"version":"6eaab464388a8b742621def40c40932bb0550813a32f70df10ecb6b2884c0c8f","impliedFormat":1},{"version":"fc94f97b7dbe8def50e4e6441cfc957a82e103358153b4bef1bf83d02c015ef0","impliedFormat":1},{"version":"6052522a593f094cfee0e99c76312a229cf2d49ac2e75095af83813ec9f4b109","impliedFormat":1},{"version":"7601b760d7679d3d678771b0719cb43b9406a3e10122da583f11b34ec96ebdbc","impliedFormat":1},{"version":"a63ce903dd08c662702e33700a3d28ca66ed21ac0591e1dbf4a0b309ae80e690","impliedFormat":1},{"version":"b9a7df08c1eebb4be745018c2eb1274bb8f3c833806a80bee366adeb6345bd4e","impliedFormat":1},{"version":"0e112389b534d19d42f5033e73cecbf189c7f1666853eb453649ae490595bb27","impliedFormat":1},{"version":"8f4844e37b671b16f618029c46ed308f8eecf129f7465d20f150b0bc2b505ac2","impliedFormat":1},{"version":"2ce8dcdc7d6ba8e1702e1d4aa2687d62990678ab518e26ac4d5495aa78199b14","impliedFormat":1},{"version":"b34fe66e28be3aaf3987b2ebb0f6553e63c54ba9d24ce81dc8666a472de5f46b","impliedFormat":1},{"version":"6e2d2b63c278fd1c8dd54da2328622c964f50afa62978ed1a73ccd85e99a4fc7","impliedFormat":1},{"version":"8bc28fd0aeb868da5ab03d778b6bfc14fd0243bc04495d0d897cb7e3cb4bfca8","impliedFormat":1},{"version":"f642b9a36789a744a3f269de516bdd08675bceda13ee45d26bc0302e9ec2dabe","impliedFormat":1},{"version":"6ce50ada4bc9d2ad69927dce35cead36da337a618de0a2daaaeeafe38c692597","impliedFormat":1},{"version":"13b8d0a9b0493191f15d11a5452e7c523f811583a983852c1c8539ab2cfdae7c","impliedFormat":1},{"version":"e8f45424b7cace1ce8c65052d4ee0c014b22e5aa3c114ae6fea32cef0f3d9c82","impliedFormat":1},{"version":"068f5afbae92a20a5fcd9cfce76f7b90de2c59a952396b5da225b61f95a1d60a","impliedFormat":1},{"version":"e97649774336f99385c03380cc4a1dbab65123c35cb3172f36ddef2f319a2ff9","impliedFormat":1},{"version":"a99bbc08536893273b1faa9c07c59c862f0fd363475a31d0c4b7bfc6df170c35","impliedFormat":1},{"version":"33a2af54111b3888415e1d81a7a803d37fada1ed2f419c427413742de3948ff5","impliedFormat":1},{"version":"0d364dcd873ebebc7d9c47c14808e9e179948537e903e76178237483581bbf6c","impliedFormat":1},{"version":"3fab75b3b823bf174ea1cee355e5bfb222277da1f8f9848f42150a05f5c3921b","impliedFormat":1},{"version":"14e655243975208ff46b52e65b9b36e3225dc610ffdd61afd8878565e2b62f3d","impliedFormat":1},{"version":"8c4224b82437321e1ba75fd34a0c1671e3ddcd8952b5c7bb84a1dead962ff953","impliedFormat":1},{"version":"e65e42a4d26b35a605baf789c348ee70220f72995c5ee6128a40328d3e8701c1","impliedFormat":1},{"version":"b5f27501077287cafa1257a91181b02c2c5fc6118206974960ee35c947bff460","impliedFormat":1},{"version":"f5f41e3a8df5eaa79ba16ae9c5f114beae9c2b32bb976a6175ecf3e2e975d10e","impliedFormat":1},{"version":"8a705ea6df44796af9df7704e6b7bc4fbff126fce0066fc9719936cc5668d054","impliedFormat":1},{"version":"fc8f837ef36ac7748fed8d55cce33bb3b3e8c10082f1f42512606c9b91e71b74","impliedFormat":1},{"version":"d080548751209b1ebf7f8e6284a82d8f87998fedce00f3872f513d4c11bad9d0","impliedFormat":1},{"version":"0f8107c8cc078f31adc9e1928c6f7b33230223f143ae183468a5ea3a7889b55b","impliedFormat":1},{"version":"38a131409a186927cc36d6cd16b9195a370082ff4cbecf60b23c9f7e5cd39901","impliedFormat":1},{"version":"81b262fe146dae64043337c7479a43b6ae67e74ac02c0729769e3d6e76d4d858","impliedFormat":1},{"version":"3051e0c946698682b8746ff3224ae5237435852c42a5179275358d5f547b71f7","impliedFormat":1},{"version":"4c7aa04345d784f2c8f96216370dafe86435add65ad0adcae5c1d2b82cd40a05","impliedFormat":1},{"version":"8fece074d02a27532eb2285f4f6803e98d7db8c956218d996910f2a961ee0fab","impliedFormat":1},{"version":"28675d40ec83b792b3003736fb009851b9729e70b7c97639625a0af5da4e0596","impliedFormat":1},{"version":"ad750b859d04354baa92aa0f02aafb3948ec2ae53c57906749ce94a0a2379ff4","impliedFormat":1},{"version":"4e8cec3e1789d0fe24376f6251e5cbe40fc5af278c7505d19789963570d9adee","impliedFormat":1},{"version":"7484b1e25cc822d12150f434159299ab2c8673adf5bd2434b54eb761ede22f76","impliedFormat":1},{"version":"9682bab70fa3b7027a9d30fb8ae1ee4e71ecb207b4643b913ba22e0eaf8f9b35","impliedFormat":1},{"version":"d7ed6d8bcc8c8d86a4307178e89cad6c88aac374fe87804c0bc7a0cc52c61a81","impliedFormat":1},{"version":"cff89395b8a7727af0a881b510273d74ce9df0fb6b640f6f4ce21da067485c2b","impliedFormat":1},{"version":"b713dea10b669b9d43a425d38525fc9aa6976eff98906a9491f055b48ee4d617","impliedFormat":1},{"version":"fb0ca8459e1a3c03e7f9b3f56b66df68e191748d6726c059732e79398abb9351","impliedFormat":1},{"version":"f83a4510748339b4157417db922474b9f1f43c0dc8dda5021b5c74923ed9a811","impliedFormat":1},{"version":"3d04566611a1a38f2d2c2fc8e2574c0e1d9d7afd692b4fcd8dc7a8f69ec9cd65","impliedFormat":1},{"version":"0052687c81e533e79a3135232798d3027c5e5afff69cd4b7ccc22be202bbbf4f","impliedFormat":1},{"version":"aa585adb25c3751a39bb6c6663ab1988f6dfd46f8225c0da12719e060562939e","impliedFormat":1},{"version":"a49ee6249fff5005c7b7db2b481fc0d75592da0c097af6c3580b67ce85713b8f","impliedFormat":1},{"version":"b88fbb95e567a0fa2df81bdd82b88b13545d79453787bda4543c0369f4f6d568","impliedFormat":1},{"version":"fd4a83bdc421c19734cd066e1411dae15348c25484db04a0a2f7029d1a256963","impliedFormat":1},{"version":"af31f37264ea5d5349eec50786ceca75c572ed3be91bdd7cb428fdd8cd14b17c","impliedFormat":1},{"version":"8d56fb4ae16943117591d60ffd52f4544affc46c44111b492d4f2ab51ff5268c","impliedFormat":1},{"version":"40683566071340b03c74d0a4ffa84d49fedb181a691ce04c97e11b231a7deee4","impliedFormat":1},{"version":"c53674e899725630a469dadd5cd0827b85903d5435afb784cacbe41c5e8c9eef","impliedFormat":1},{"version":"e885933b92f26fa3204403999eddc61651cd3109faf8bffa4f6b6e558b0ab2fa","impliedFormat":1},{"version":"5852ec0e134dda28852eada61248ab2b8027aa1238340ccc407234f013627f61","impliedFormat":1},{"version":"0463dbee62e1e2f1692ece7b08d31c329e642114355426606b390aab7978414e","impliedFormat":1},{"version":"f6bf2b22f3af7ddb26f9a93b47f8747547ecb598ca5b3002d9e76f72a65809b5","impliedFormat":1},{"version":"6733e3a832f92b68e7368878cfb4e54a4b942361e87a0b8fa2a475ec9369ad03","signature":"e05f7241b9f0d8920509251c4334b674d7dfe32fc4dd7901c62508cf53424b0d"},{"version":"17c51c1633a7319e25ba1a52fd4af4cc47d6cc29d6d5fb8cab402aaa343f564e","signature":"bfa004f2f9c7aa15ae4065af42d2564124d5a3cdbc806aff60e8ea1646355417"},{"version":"5c1b479320c1e8727815f025889d437a51d7d9864141e1f2482b28ea65dc322c","signature":"0e9d205bf2e600c2985999726bac6490e2c0ed9e3646cc1e0e7f988b9463f9a6"},{"version":"8ee77e3b2e0b27a14404546146fb18f17a05a2ec9605857bfcbbedcd9705e2df","signature":"1875f9aee1a1e88b821c49e02e35d163013f9b1a672b0097478379cfafd87d06"},{"version":"cd8d704e31ca6e772eaaed0d1abbda5131968d07da6295ec31ca25f2f96f4603","signature":"8d23da0bcd77e78b20a2f20624973b039d3013ebf0fabd0c8e0615c58e74489f"},{"version":"fb53d08863f113ec1c8bc2c5d543d625551e28e401b29e5988f6ce4259ef935f","signature":"8670ec89de827a6e9d8f0f268b29a415094ea5137e91e60da027ded8ad5cc098"},{"version":"fd432f424507ee57ff25fc592c2a0b16f28fa56deb4df236653654ecec348789","signature":"81e691d34825e62f13beb4439db7e04a3a7b4610ed434bc8b7d0e2f05436fb75"},{"version":"d3cfde44f8089768ebb08098c96d01ca260b88bccf238d55eee93f1c620ff5a5","impliedFormat":1},{"version":"293eadad9dead44c6fd1db6de552663c33f215c55a1bfa2802a1bceed88ff0ec","impliedFormat":1},{"version":"206e73f49f16633113787cc651dc03dc900379395dfa02ab1ef4c9cbbcd5adc2","impliedFormat":1},{"version":"fec412ded391a7239ef58f455278154b62939370309c1fed322293d98c8796a6","impliedFormat":1},{"version":"e3498cf5e428e6c6b9e97bd88736f26d6cf147dedbfa5a8ad3ed8e05e059af8a","impliedFormat":1},{"version":"dba3f34531fd9b1b6e072928b6f885aa4d28dd6789cbd0e93563d43f4b62da53","impliedFormat":1},{"version":"f672c876c1a04a223cf2023b3d91e8a52bb1544c576b81bf64a8fec82be9969c","impliedFormat":1},{"version":"e4b03ddcf8563b1c0aee782a185286ed85a255ce8a30df8453aade2188bbc904","impliedFormat":1},{"version":"2329d90062487e1eaca87b5e06abcbbeeecf80a82f65f949fd332cfcf824b87b","impliedFormat":1},{"version":"25b3f581e12ede11e5739f57a86e8668fbc0124f6649506def306cad2c59d262","impliedFormat":1},{"version":"93c3e73824ad57f98fd23b39335dbdae2db0bd98199b0dc0b9ccc60bf3c5134a","impliedFormat":1},{"version":"a9ebb67d6bbead6044b43714b50dcb77b8f7541ffe803046fdec1714c1eba206","impliedFormat":1},{"version":"833e92c058d033cde3f29a6c7603f517001d1ddd8020bc94d2067a3bc69b2a8e","impliedFormat":1},{"version":"8e6427dd1a4321b0857499739c641b98657ea6dc7cc9a02c9b2c25a845c3c8e6","impliedFormat":1},{"version":"58da08d1fe876c79c47dcf88be37c5c3fab55d97b34c8c09a666599a2191208d","impliedFormat":1},{"version":"2576c3edc78797e0206c738577de487893253780821e977c690eeeb1bc4c3b71","signature":"efdd399105978f071ab08cbbd26ba9774eb8bc990875bcebbaeb7107c14b9abe"},{"version":"e0abef7b1ec7dc3ad032e42117b71af506dac4ab72de066f659d03eaa72c0fd0","signature":"f6b3e4bb6826a124241d49968dda0d6990bbaf6be48f1c51761e103543100be2"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"cc3738ba01d9af5ba1206a313896837ff8779791afcd9869e582783550f17f38","impliedFormat":99},{"version":"3b217e02ad520f3d63c5ccc6d8870c91c1da51d8c0f09e834c3415ef051c1dfb","signature":"e7f0196b8c2cc640e4d5841868b7ce67c41d306262e568d0132ddafab39bc157"},{"version":"17247b09a117c79610d682568e2ba37566d96d2333d3540a66d0f8755a54893c","signature":"dcf0caf6d631c1007de4e649c1fb92791bf5ac0eb55d286bffd7cf12ab399d66"},{"version":"60583b38c087b1b225aa077efba28c701eb1f0e1d1705a6f2f6a7e230df016b6","signature":"0bf3a611a7c2af01c27149e0b9fe9c61af5a287b74b266f0f0ebe7dcf339ad5e"},{"version":"27ee9f713987f8a884c7f8cd7743a10457f1768170cfe9750d84b0a158c5c486","signature":"73e926168d0f3f2ea7932a8fddbc68b69e4f089597b7a6ce13ce42a5a89440ab"},{"version":"64c6bb953b8d78268eadd3539bd97e09eac8bd2b736f80c6fb96f3585d830e9e","signature":"29de3fc2a14cc92861e585b05d11a88332ff1a12ea656e49b449062062b31350"},{"version":"bb703864a1bc9ca5ac3589ffd83785f6dc86f7f6c485c97d7ffd53438777cb9e","impliedFormat":1},{"version":"a171f27504ba8bfa244cb257956e01601f6f98a348e0cb94dc77e201260e377f","signature":"34695ed66680ea492a62489b33cfd7bfa9529b696be1bc23384122f471208d00"},{"version":"047ef8187c382abbdd2d751ef1a5c4fb065aaeef6557483e2bd6d7ec6153aa8f","signature":"74052560a70381575989a8c7787e5c6094299ea4ef6b4bd9c7b49e1480c40eec"},{"version":"3c7819d0bd2370ec46aa83ddd33c9a0b177e9e6587a7d94ee9a6d6961540ec6f","signature":"34817f7aafffd4d1b276bb56dafa1ff55e6f38336862dbd0efe15e83dfcfcdc5"},{"version":"6d3bacd5150ba69409c66fdd6d34dd40936319692a793d0d313d5834a48c5b4a","signature":"e7ae15fba5ca5e6f6c5feb87053b004ef3e7ed91c61811dec07b556028050c29"},{"version":"734c978a53643112e0939f3493758ff2651ca56aa92f180cda3a0542274baff6","signature":"5710b2220aa08a5cdec279bc67698116171d4334ca0dbdb19e1b0f1e923f2523"},{"version":"96d87913d6fc27df14759c6892fc97bb07c843b52a3e3ef23e2c9cd5f3856f32","signature":"02aba73a5ca1a835386bb3084dd25ac2a664dee48a1f85f850986bb6c7bc3592"},{"version":"f467fc85a8b59e7c1bc8a56d795b00b7e080221c286e13218a26d1265b854116","signature":"e65416c124c9f46e7c3821cde9224b2900f734c3763aa7154bce71b8c97a2c0a"},"be72b898619c9a7cadb7771cc3176b3f9739228e65ca3b8c5470c62d74a4cc9a",{"version":"e7441be68f390975c6155c805cea8f54cc1b7f3656b6b9440ecbbbd7753499e6","impliedFormat":99},{"version":"5a99d073185e0ef6d984436547dce1f99c333dde7c1d7f33a2155dce05216514","signature":"a62a952464813ad6681414a2f6708d8d8cb5ccb7ee948cef6e7f7d6f11869795"},"56897393338cb1107179ac9a54d38e0d5c6e4a38354c4b522edf8160b2ec67b1",{"version":"31c30cc54e8c3da37c8e2e40e5658471f65915df22d348990d1601901e8c9ff3","impliedFormat":99},{"version":"a6f9e326f19cfa485b3a6c2eb7b9829c42f8012f29820cefab0b10dd5c1cb2fa","signature":"870119a5f3f2da219ba16214980357bbf0dd1f2bcfd77fd35da7d8465c0ae708"},{"version":"ad14d7864ec595f8f9224a085083fffd0137150d803092803b146643434d48a7","signature":"ade22b42ad26354dbff601e10439a06d15581696425231bd83fe6517a9438b0d"},{"version":"b5709d2685ca90ea786a0dada56b710eaccfa6076327e4499c9ec86962f99aa7","signature":"e9215c110843d60cdcf28e5fa8144522681de43094a89e06e3855f7990f49a7f"},{"version":"5d0c5e767bf2a6f08629a58b6a89b7d91a81f6e35d9167bfda0bd9f1e2357b4e","signature":"f515561294f9cdcee8482e9c653ee65f600d63832257edb86a2f2f5a0cc1b64e"},{"version":"2a8ab4ff76618819e70fea2c26ac539752081c533ef71c54bc277ca5189b3b4c","signature":"b819d8b90a2f2e2b67c15c59eed25430cc7ed831fd114e567ff88833fa4b5de5"},{"version":"a3fdab7f3518dcf4f8ce865cb48dbe9a0b5a5150b543cb4c7120cc2b8608f8c6","signature":"97b88cd12c3dda2a5fc7c2e658d589781dd5aba8920d00c252a623198190e172"},"e1e3a9b51aa9eb884d3aece89c538bfd17405681917401afb2ba9a464426161c",{"version":"0f934c0caf78cbeb8fe88bf4f95d3b18f8347a322872d7700fb42eef5ecefd42","signature":"9dff8a85e580b32a38517861c4adeaa44f516d226f8762207a57be459aa996ab"},"7950cde48ecc99f323e3c86093a465d91a33aee84f4a2888364944f8c3febf0c","4012abed7b39073f7497b340722ccf697db4df2b453fe6618656282d235e1172",{"version":"2ddbf67b826f80f978e93a798a2bccc8867c4b8bc46c69f86634401e2d336dad","signature":"abec593d0c5872aced84afb7046990d70b3016feebce6e521e6845d7998a219e"},{"version":"0b5fb5eca5212255296bc4a6559e4a02d253d2ae2d6fc2b62fa285cdfec3786e","signature":"ea30d960932ca79984691953e1c38879c34a3dd702bca3b68b06947169e9e829"},"4dff76748f5251bd396a7cf3277665fde991f269758b6037a018c9835a80cdff","6706be8adddc5a11c7a04d42f0c0dff0f152065d20eba21f9d113917ce879d33",{"version":"21f41ce5777146a8d8e525ad31cc8d364bb9f8508ebd7a01e77733b567fcbc0f","signature":"690bfa869de9227da8088d725491edf0c11b2620e734c02f87ac2253323b71c1"},"804f666536b79401690b447ad796a81c36bdfb95a3043101bffafb8c1056aca9","23a6e9e2fb0ce3ea299b33e644dc16975d5889443adf27ecea3d946fe642f2ad",{"version":"cd8d704e31ca6e772eaaed0d1abbda5131968d07da6295ec31ca25f2f96f4603","signature":"8d23da0bcd77e78b20a2f20624973b039d3013ebf0fabd0c8e0615c58e74489f"},{"version":"fd432f424507ee57ff25fc592c2a0b16f28fa56deb4df236653654ecec348789","signature":"81e691d34825e62f13beb4439db7e04a3a7b4610ed434bc8b7d0e2f05436fb75"},{"version":"6d3bacd5150ba69409c66fdd6d34dd40936319692a793d0d313d5834a48c5b4a","signature":"e7ae15fba5ca5e6f6c5feb87053b004ef3e7ed91c61811dec07b556028050c29"},{"version":"734c978a53643112e0939f3493758ff2651ca56aa92f180cda3a0542274baff6","signature":"5710b2220aa08a5cdec279bc67698116171d4334ca0dbdb19e1b0f1e923f2523"},{"version":"13680c9726421b79c1957bf5f06d3deec35e7e5a113c49583b037ffab6ec6d39","signature":"c3b82b731c1bfda402eba10f9df571580d1f5a674d5ca43ce97a933ee02c2d22"},{"version":"1ca52accaf2273cc86e913b388ba0c36f4e4d8e19b3f9b015e81eea6c4ae5960","signature":"2a618d1e67da91688d27b94c9b241bbfba39b5cc1634eec5587a9288744c45c3"},{"version":"d752035cf295253d806c763d4f1ffcfa9afe49210355fbfd8b833376e56e1109","signature":"a9f7d0693bbfc1b3167c19e6756b12e8acc591d96dbb553a5a4a27ba4e4a35b4"},{"version":"c1a2518a277db331f5506a94c74afcae9f9d3287ed659b7a91407c28ed6ed6c6","signature":"63bde153cfa3cf0afe2a2a36aafa1a130e4b2caf41652c5d1dcbfaa0d6a9148c"},{"version":"5824604e17ce23f1d5aa3ce8092e4c284897551816aad2532e17477c597aaa7d","signature":"e27aa7e6f6113a7b2c84125c2b9a273b8c06c822d94d1bdca4cdb0aa4ce5de0e"},{"version":"f142d5c2f148ecb72e45eaa5152a642ab1956e0a3235896b2eda30a6c4a8e0a8","signature":"11f5be9abc00c11cd52420abfbc71561ec3cdb19f272077b1eedfc066110e2f4"},{"version":"c351dc34a026a2e3ea1b23b2eb0d9d95a60599a156a6029d03607de67e715627","signature":"f138d5ffbc374cc396b5347b8fd34f866962b2540e7d85b69c0de168946ee499"},{"version":"b079f4f7c7f30fe5f18a16da3bffe8b439d39b2f183da9619676785d146fbddf","signature":"03b3f37254f409de74197b73b0fe0b53f3f8f678c84f6b54100124fb42f43b2d"},{"version":"c4b2d51845b74850aa36bed5533ed4933736ce8c16d6c4d4d9368913810e0f25","signature":"dd0120bf29354d58acd0f49f8bedc41e46d9d496b6b26902311b78a87849b186"},{"version":"90b228df53065470860e3346ff83e2ab677ed5cf2d0e01cb280bd7a4a115b791","signature":"1a0ce6eb1c407fb1c2251a69942b96b24ef352db994a52f8f3f7ff486b24e9d7"},{"version":"949b7292f3f73c13024982794a3c65a27c97bd5ae0d32a5cedbae3b651c25710","signature":"1731e754c54d37e855f6868dba2b6e7fe7426ee9bd7771dc04d36c2fea543f19"},{"version":"23da7d6bbabd2eee6243b5582842b69067b0ed93f80d9e1a3f05894d3cdf5741","signature":"84be38e8f2bd80191759cbeb534801b22e32f8c91fef8176dc7c45cd69dadea3"},{"version":"f48eb40e426a9c3cf66bc5fe145bec945f186964536f0a8366cd2d0997298b8f","signature":"b49934ea0ebed672b4554b54ebf5047afe63d4212a629920553e3c4f98d1e210"},{"version":"a9373d52584b48809ffd61d74f5b3dfd127da846e3c4ee3c415560386df3994b","impliedFormat":99},{"version":"cbfd5ef0c8fdb4983202252b5f5758a579f4500edc3b9ad413da60cffb5c3564","impliedFormat":99},{"version":"956cf4b485bcf57684caac10df2aa2a72387d0736d8f4cd1315c49ebd2da4615","signature":"1eb20268ebe644e6df6078e14bce71cc71590d43c562b4d3fdc2375777bca31a"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"233267a4a036c64aee95f66a0d31e3e0ef048cccc57dd66f9cf87582b38691e4","impliedFormat":99},{"version":"0397ed074259c28d961b3567cf425d491b6b434fff93bc25eea2fc93bbd75f7a","signature":"b49f7ee0feb128c542b7a46a8af92fd18942b5460e80d7be8aabd8ce507764d8"},{"version":"b598b1e9481a930b5f9e38e0e41a4267722ecb641d41a46ad04a0873fb92eb31","signature":"00ca1d2d1160f655bf2eb98c3454f9043ec52d5c63d7c8b360122b4afe4c27d9"},{"version":"9990f21aad5b08bd1367c26eaf653379fbd3cbf1c73835d7c89558a897cdb9e4","signature":"ffa79f62c536266410190ee8d522f68b1e8a1a01fb705451c8c2c987df92e062"},{"version":"1dbd248b251538341f7b6d921c1972569ec7f3f7f5897123fc00148f6bdc0e57","signature":"354030b88a182802d063fb8096a34d9d23b69d2f48db10277488475dde054919"},{"version":"42adab75a647248b224a23d3b6b398efcee1b6b417cdcc4f32bc50cf6fba266d","signature":"6912fcc8e7b93e970fc0018c59d7606df75f8d62b342ef5e9d74eb08ba50b6d1"},{"version":"ab85664862c198191ba3d77d3a0e271a26c949093cabd88b74f5079484b3c69c","signature":"ca272dae169954a9e3dad0b8ec2acc9b69b9c292508909a8ddd4f9412a01e6c3"},{"version":"c0b208999b2e53020a7b2a1d8d4ac67bec87651389bd630ac2e8d632fa839b10","signature":"17d95f0fda80b532996dc589a631ac937896df66be49ac9b0b381e028dfe9e85"},{"version":"c892fb76ede9506711319412d369bc666c1a574d16d6559f0aea873d55d07cfc","signature":"f23885a1b16d6b8c10966100c439eef43e2a0a82c0a43c2abd239f01ea9188be"},{"version":"146072a9d4178049116796062a37421cdf09f0bd06390a69a1fb76daf71dcb11","signature":"3a663b83bd70cae5c1b7e453f52eaab61f1f382c44d69c7b4491da5058239b2a"},{"version":"3aa160f473ca0af44d500c6bed1af5f5d9ad4ffb2884b4ca34e59989dd5d90e4","signature":"c416f65676cd621ef92478b644323536b31d366476693fa2f9a15063cd1d6ff5"},"2552a31fad45a9ed1bde87e51b038dc0e786cd364b597162263abbf57018949b",{"version":"6c1b1a7df2ef20edea7af3b853134925e9fe26e3f6cb51b04201ecd6ae35e284","affectsGlobalScope":true},"e8d8cd9625ec6cca3487427e67839eed80d92b7a71e5b86d5e2bfd7aaf4f38ea",{"version":"1ff6028b5b6ccb9af8d5789deaff14ff09a6ab61cdb619eb383395989edffa2c","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"386b6553763e4688817838bf6cc7d51a504cac0dd9ca96f46600874fbb72dfad","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"7e684095a2d1cdd296f6c85e01108415c3ac1bc7d9e4e2f53794e9bea9c96209","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},"b6987d179737a82a85e4004adf041b441a8fda6f31ce061bd57eaa8cdca0c46f",{"version":"f6f8307d1cd2a2f262f6a03d1bc4eaae1008540dd689749a1d55817bda99ddd4","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"c609171dc1f4060d39c937c4271322c028f0bc6387c439b8bc0bdfa966e1c463","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"39749520c8e365ea4ac255752171fc222f4961d5e6d15ff24c3a76807178ff41","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"b1538a92b9bae8d230267210c5db38c2eb6bdb352128a3ce3aa8c6acf9fc9622","impliedFormat":1},{"version":"6fc1a4f64372593767a9b7b774e9b3b92bf04e8785c3f9ea98973aa9f4bbe490","impliedFormat":1},{"version":"ff09b6fbdcf74d8af4e131b8866925c5e18d225540b9b19ce9485ca93e574d84","impliedFormat":1},{"version":"d5895252efa27a50f134a9b580aa61f7def5ab73d0a8071f9b5bf9a317c01c2d","impliedFormat":1},{"version":"56208c500dcb5f42be7e18e8cb578f257a1a89b94b3280c506818fed06391805","impliedFormat":1},{"version":"0c94c2e497e1b9bcfda66aea239d5d36cd980d12a6d9d59e66f4be1fa3da5d5a","impliedFormat":1},{"version":"1f366bde16e0513fa7b64f87f86689c4d36efd85afce7eb24753e9c99b91c319","impliedFormat":1},{"version":"151ff381ef9ff8da2da9b9663ebf657eac35c4c9a19183420c05728f31a6761d","impliedFormat":1},{"version":"f3d8c757e148ad968f0d98697987db363070abada5f503da3c06aefd9d4248c1","impliedFormat":1},{"version":"96d14f21b7652903852eef49379d04dbda28c16ed36468f8c9fa08f7c14c9538","impliedFormat":1},{"version":"7fa8d75d229eeaee235a801758d9c694e94405013fe77d5d1dd8e3201fc414f1","impliedFormat":1}],"root":[83,497,502,510,511,[517,528],[531,534],539,543,[557,559],[564,573],[576,579],1013,1023,1024,[1027,1036],1109,1110,[1142,1170],[1172,1183],[1188,1196],[1300,1306],[1316,1321],1325,1326,[1330,1335],[1340,1350],[1466,1472],1488,1489,[1492,1496],[1498,1505],1507,1508,[1510,1543],1546,[1549,1568]],"options":{"allowJs":true,"esModuleInterop":true,"jsx":1,"module":99,"skipLibCheck":true,"strict":true,"target":4},"referencedMap":[[1564,1],[1563,2],[1565,3],[1566,4],[1562,5],[1567,6],[1568,7],[1559,8],[83,9],[1560,10],[1561,11],[511,12],[497,13],[502,14],[934,9],[935,15],[936,16],[941,17],[937,16],[940,9],[938,9],[939,9],[1239,18],[1201,9],[1202,9],[1203,9],[1245,18],[1240,9],[1204,9],[1205,9],[1206,9],[1207,9],[1247,19],[1208,9],[1209,9],[1210,9],[1211,9],[1216,20],[1217,21],[1218,20],[1219,20],[1220,9],[1221,20],[1222,21],[1223,20],[1224,20],[1225,20],[1226,20],[1227,20],[1228,21],[1229,21],[1230,20],[1231,20],[1232,21],[1233,21],[1234,20],[1235,20],[1236,9],[1237,9],[1246,18],[1213,9],[1241,9],[1242,22],[1243,22],[1215,23],[1214,24],[1244,25],[1238,9],[1252,26],[1255,27],[1254,26],[1253,28],[1251,29],[1248,9],[1250,30],[1249,31],[1487,32],[1486,33],[244,9],[509,34],[1509,35],[549,36],[548,37],[537,38],[536,37],[535,37],[1185,39],[1184,37],[545,36],[544,37],[1339,40],[1336,37],[547,36],[546,37],[575,41],[1338,42],[1337,37],[1022,43],[1018,44],[1014,37],[1016,44],[1017,44],[1020,45],[1021,44],[1015,37],[1019,9],[552,46],[550,37],[554,36],[553,37],[574,37],[1545,47],[1544,37],[562,48],[561,37],[556,49],[555,37],[1491,48],[1490,37],[540,50],[1026,48],[1025,37],[563,51],[560,37],[1548,52],[1547,37],[1187,36],[1186,37],[551,9],[1369,53],[1368,9],[1267,9],[1569,9],[1570,9],[1571,9],[1572,54],[1354,9],[1574,55],[1355,56],[1573,9],[1575,9],[1576,9],[1577,9],[1578,9],[143,57],[144,57],[145,58],[100,59],[146,60],[147,61],[148,62],[95,9],[98,63],[96,9],[97,9],[149,64],[150,65],[151,66],[152,67],[153,68],[154,69],[155,69],[156,70],[157,71],[158,72],[159,73],[101,9],[99,9],[160,74],[161,75],[162,76],[194,77],[163,78],[164,79],[165,80],[166,81],[167,82],[168,83],[169,84],[170,85],[171,86],[172,87],[173,87],[174,88],[175,9],[176,89],[178,90],[177,91],[179,92],[180,93],[181,94],[182,95],[183,96],[184,97],[185,98],[186,99],[187,100],[188,101],[189,102],[190,103],[191,104],[102,9],[103,9],[104,9],[142,105],[192,106],[193,107],[198,108],[354,37],[199,109],[197,110],[356,111],[355,112],[195,113],[352,9],[196,114],[84,9],[86,115],[351,37],[262,37],[1579,9],[542,116],[541,117],[529,9],[1497,118],[85,9],[668,119],[647,120],[744,9],[648,121],[584,119],[585,119],[586,119],[587,119],[588,119],[589,119],[590,119],[591,119],[592,119],[593,119],[594,119],[595,119],[596,119],[597,119],[598,119],[599,119],[600,119],[601,119],[580,9],[602,119],[603,119],[604,9],[605,119],[606,119],[608,119],[607,119],[609,119],[610,119],[611,119],[612,119],[613,119],[614,119],[615,119],[616,119],[617,119],[618,119],[619,119],[620,119],[621,119],[622,119],[623,119],[624,119],[625,119],[626,119],[627,119],[629,119],[630,119],[631,119],[628,119],[632,119],[633,119],[634,119],[635,119],[636,119],[637,119],[638,119],[639,119],[640,119],[641,119],[642,119],[643,119],[644,119],[645,119],[646,119],[649,122],[650,119],[651,119],[652,123],[653,124],[654,119],[655,119],[656,119],[657,119],[660,119],[658,119],[659,119],[582,9],[661,119],[662,119],[663,119],[664,119],[665,119],[666,119],[667,119],[669,125],[670,119],[671,119],[672,119],[674,119],[673,119],[675,119],[676,119],[677,119],[678,119],[679,119],[680,119],[681,119],[682,119],[683,119],[684,119],[686,119],[685,119],[687,119],[688,9],[689,9],[690,9],[837,126],[691,119],[692,119],[693,119],[694,119],[695,119],[696,119],[697,9],[698,119],[699,9],[700,119],[701,119],[702,119],[703,119],[704,119],[705,119],[706,119],[707,119],[708,119],[709,119],[710,119],[711,119],[712,119],[713,119],[714,119],[715,119],[716,119],[717,119],[718,119],[719,119],[720,119],[721,119],[722,119],[723,119],[724,119],[725,119],[726,119],[727,119],[728,119],[729,119],[730,119],[731,119],[732,9],[733,119],[734,119],[735,119],[736,119],[737,119],[738,119],[739,119],[740,119],[741,119],[742,119],[743,119],[745,127],[933,128],[838,121],[840,121],[841,121],[842,121],[843,121],[844,121],[839,121],[845,121],[847,121],[846,121],[848,121],[849,121],[850,121],[851,121],[852,121],[853,121],[854,121],[855,121],[857,121],[856,121],[858,121],[859,121],[860,121],[861,121],[862,121],[863,121],[864,121],[865,121],[866,121],[867,121],[868,121],[869,121],[870,121],[871,121],[872,121],[874,121],[875,121],[873,121],[876,121],[877,121],[878,121],[879,121],[880,121],[881,121],[882,121],[883,121],[884,121],[885,121],[886,121],[887,121],[889,121],[888,121],[891,121],[890,121],[892,121],[893,121],[894,121],[895,121],[896,121],[897,121],[898,121],[899,121],[900,121],[901,121],[902,121],[903,121],[904,121],[906,121],[905,121],[907,121],[908,121],[909,121],[911,121],[910,121],[912,121],[913,121],[914,121],[915,121],[916,121],[917,121],[919,121],[918,121],[920,121],[921,121],[922,121],[923,121],[924,121],[581,119],[925,121],[926,121],[928,121],[927,121],[929,121],[930,121],[931,121],[932,121],[746,119],[747,119],[748,9],[749,9],[750,9],[751,119],[752,9],[753,9],[754,9],[755,9],[756,9],[757,119],[758,119],[759,119],[760,119],[761,119],[762,119],[763,119],[764,119],[769,129],[767,130],[768,131],[766,132],[765,119],[770,119],[771,119],[772,119],[773,119],[774,119],[775,119],[776,119],[777,119],[778,119],[779,119],[780,9],[781,9],[782,119],[783,119],[784,9],[785,9],[786,9],[787,119],[788,119],[789,119],[790,119],[791,125],[792,119],[793,119],[794,119],[795,119],[796,119],[797,119],[798,119],[799,119],[800,119],[801,119],[802,119],[803,119],[804,119],[805,119],[806,119],[807,119],[808,119],[809,119],[810,119],[811,119],[812,119],[813,119],[814,119],[815,119],[816,119],[817,119],[818,119],[819,119],[820,119],[821,119],[822,119],[823,119],[824,119],[825,119],[826,119],[827,119],[828,119],[829,119],[830,119],[831,119],[832,119],[583,133],[833,9],[834,9],[835,9],[836,9],[1460,9],[1212,9],[1365,9],[1259,134],[1257,135],[1258,9],[1256,136],[538,37],[1329,137],[516,138],[515,139],[514,140],[501,141],[499,142],[500,143],[498,9],[1328,144],[513,145],[512,9],[1299,146],[1294,147],[1280,147],[1296,148],[1295,149],[1291,148],[1279,147],[1292,148],[1293,147],[1298,150],[1297,148],[1327,151],[93,152],[443,153],[448,8],[450,154],[220,155],[248,156],[426,157],[243,158],[231,9],[212,9],[218,9],[416,159],[279,160],[219,9],[385,161],[253,162],[254,163],[350,164],[413,165],[368,166],[420,167],[421,168],[419,169],[418,9],[417,170],[250,171],[221,172],[300,9],[301,173],[216,9],[232,174],[222,175],[284,174],[281,174],[205,174],[246,176],[245,9],[425,177],[435,9],[211,9],[326,178],[327,179],[321,37],[471,9],[329,9],[330,180],[322,181],[477,182],[475,183],[470,9],[412,184],[411,9],[469,185],[323,37],[364,186],[362,187],[472,9],[476,9],[474,188],[473,9],[363,189],[464,190],[467,191],[291,192],[290,193],[289,194],[480,37],[288,195],[273,9],[483,9],[486,9],[485,37],[487,196],[201,9],[422,197],[423,198],[424,199],[234,9],[210,200],[200,9],[342,37],[203,201],[341,202],[340,203],[331,9],[332,9],[339,9],[334,9],[337,204],[333,9],[335,205],[338,206],[336,205],[217,9],[208,9],[209,174],[263,207],[264,208],[261,209],[259,210],[260,211],[256,9],[348,180],[370,180],[442,212],[451,213],[455,214],[429,215],[428,9],[276,9],[488,216],[438,217],[324,218],[325,219],[316,220],[306,9],[347,221],[307,222],[349,223],[344,224],[343,9],[345,9],[361,225],[430,226],[431,227],[309,228],[313,229],[304,230],[408,231],[437,232],[283,233],[386,234],[206,235],[436,236],[202,158],[257,9],[265,237],[397,238],[255,9],[396,239],[94,9],[391,240],[233,9],[302,241],[387,9],[207,9],[266,9],[395,242],[215,9],[271,243],[312,244],[427,245],[311,9],[394,9],[258,9],[399,246],[400,247],[213,9],[402,248],[404,249],[403,250],[236,9],[393,235],[406,251],[392,252],[398,253],[224,9],[227,9],[225,9],[229,9],[226,9],[228,9],[230,254],[223,9],[378,255],[377,9],[383,256],[379,257],[382,258],[381,258],[384,256],[380,257],[270,259],[371,260],[434,261],[490,9],[459,262],[461,263],[308,9],[460,264],[432,226],[489,265],[328,226],[214,9],[310,266],[267,267],[268,268],[269,269],[299,270],[407,270],[285,270],[372,271],[286,271],[252,272],[251,9],[376,273],[375,274],[374,275],[373,276],[433,277],[320,278],[358,279],[319,280],[353,281],[357,282],[415,283],[414,284],[410,285],[367,286],[369,287],[366,288],[405,289],[360,9],[447,9],[359,290],[409,9],[272,291],[305,197],[303,292],[274,293],[277,294],[484,9],[275,295],[278,295],[445,9],[444,9],[446,9],[482,9],[280,296],[318,37],[92,9],[365,297],[249,9],[238,298],[314,9],[453,37],[463,299],[298,37],[457,180],[297,300],[440,301],[296,299],[204,9],[465,302],[294,37],[295,37],[287,9],[237,9],[293,303],[292,304],[235,305],[315,86],[282,86],[401,9],[389,306],[388,9],[449,9],[346,307],[317,37],[441,308],[87,37],[90,309],[91,310],[88,37],[89,9],[247,311],[242,312],[241,9],[240,313],[239,9],[439,314],[452,315],[454,316],[456,317],[458,318],[462,319],[496,320],[466,320],[495,321],[468,322],[478,323],[479,324],[481,325],[491,326],[494,200],[493,9],[492,327],[506,328],[503,9],[504,328],[505,329],[508,330],[507,331],[999,332],[961,333],[960,334],[998,335],[1000,336],[942,37],[943,37],[944,37],[988,337],[967,338],[968,338],[969,339],[970,37],[971,37],[972,340],[945,341],[973,37],[974,37],[975,342],[976,37],[977,37],[978,37],[979,37],[980,37],[981,37],[946,341],[982,37],[983,37],[984,341],[985,37],[986,37],[987,342],[1001,339],[989,332],[990,332],[991,332],[992,332],[993,332],[994,9],[995,332],[996,343],[1002,344],[1003,345],[1012,346],[958,347],[947,348],[948,332],[949,348],[950,332],[951,9],[952,9],[953,9],[954,332],[955,332],[956,332],[957,332],[965,349],[966,350],[962,351],[963,352],[997,353],[959,37],[964,354],[1004,348],[1005,348],[1011,355],[1006,332],[1007,348],[1008,348],[1009,332],[1010,348],[1111,9],[1126,356],[1127,356],[1141,357],[1128,358],[1129,358],[1130,359],[1124,360],[1122,361],[1113,9],[1117,362],[1121,363],[1119,364],[1125,365],[1114,366],[1115,367],[1116,368],[1118,369],[1120,370],[1123,371],[1131,358],[1132,358],[1133,358],[1134,356],[1135,358],[1136,358],[1112,358],[1137,9],[1139,372],[1138,358],[1140,356],[1373,9],[1382,373],[1392,374],[1438,375],[1363,376],[1409,377],[1396,378],[1456,379],[1408,380],[1393,381],[1440,382],[1439,383],[1404,384],[1395,385],[1441,386],[1442,387],[1443,388],[1451,389],[1445,389],[1453,389],[1457,389],[1444,389],[1446,389],[1449,389],[1452,389],[1448,390],[1450,389],[1454,391],[1447,391],[1358,392],[1425,37],[1422,393],[1426,37],[1418,389],[1359,389],[1416,394],[1362,395],[1375,396],[1421,397],[1424,389],[1360,37],[1423,398],[1352,37],[1351,37],[1371,37],[1464,399],[1463,400],[1465,401],[1433,9],[1431,9],[1435,402],[1434,403],[1430,404],[1432,405],[1436,406],[1437,407],[1429,37],[1379,408],[1353,389],[1428,389],[1374,409],[1427,389],[1394,408],[1455,389],[1370,410],[1413,411],[1372,412],[1397,413],[1389,414],[1398,415],[1399,416],[1400,417],[1401,418],[1405,419],[1406,420],[1381,421],[1412,422],[1410,423],[1411,424],[1407,425],[1414,426],[1383,427],[1391,428],[1377,429],[1387,430],[1388,431],[1384,432],[1378,433],[1390,434],[1357,435],[1462,9],[1376,436],[1415,437],[1458,9],[1402,9],[1419,9],[1403,9],[1461,438],[1380,439],[1385,9],[1417,440],[1420,9],[1386,9],[1459,9],[1361,37],[1367,441],[1364,9],[1366,9],[390,442],[1171,37],[530,9],[81,9],[82,9],[13,9],[14,9],[16,9],[15,9],[2,9],[17,9],[18,9],[19,9],[20,9],[21,9],[22,9],[23,9],[24,9],[3,9],[25,9],[26,9],[4,9],[27,9],[31,9],[28,9],[29,9],[30,9],[32,9],[33,9],[34,9],[5,9],[35,9],[36,9],[37,9],[38,9],[6,9],[42,9],[39,9],[40,9],[41,9],[43,9],[7,9],[44,9],[49,9],[50,9],[45,9],[46,9],[47,9],[48,9],[8,9],[54,9],[51,9],[52,9],[53,9],[55,9],[9,9],[56,9],[57,9],[58,9],[60,9],[59,9],[61,9],[62,9],[10,9],[63,9],[64,9],[65,9],[11,9],[66,9],[67,9],[68,9],[69,9],[70,9],[1,9],[71,9],[72,9],[12,9],[76,9],[74,9],[79,9],[78,9],[73,9],[77,9],[75,9],[80,9],[120,443],[130,444],[119,443],[140,445],[111,446],[110,447],[139,327],[133,448],[138,449],[113,450],[127,451],[112,452],[136,453],[108,454],[107,327],[137,455],[109,456],[114,457],[115,9],[118,457],[105,9],[141,458],[131,459],[122,460],[123,461],[125,462],[121,463],[124,464],[134,327],[116,465],[117,466],[126,467],[106,468],[129,459],[128,457],[132,9],[135,469],[1278,470],[1197,9],[1262,9],[1274,471],[1272,472],[1200,473],[1261,474],[1271,475],[1276,476],[1268,477],[1269,9],[1277,478],[1275,479],[1266,480],[1264,481],[1263,9],[1270,9],[1260,475],[1273,9],[1199,9],[1198,37],[1265,9],[1290,482],[1289,483],[1288,484],[1281,485],[1287,486],[1283,147],[1286,476],[1284,9],[1285,147],[1282,487],[1506,118],[1356,488],[1108,489],[1477,490],[1484,491],[1479,9],[1480,9],[1478,492],[1481,493],[1473,9],[1474,9],[1485,494],[1476,495],[1482,9],[1483,496],[1475,497],[1103,498],[1106,499],[1104,499],[1100,498],[1107,500],[1105,499],[1101,501],[1102,502],[1096,503],[1041,504],[1043,505],[1095,9],[1042,506],[1099,507],[1097,9],[1044,504],[1045,9],[1094,508],[1040,509],[1037,9],[1098,510],[1038,511],[1039,9],[1046,512],[1047,512],[1048,512],[1049,512],[1050,512],[1051,512],[1052,512],[1053,512],[1054,512],[1055,512],[1056,512],[1057,512],[1058,512],[1060,512],[1059,512],[1061,512],[1062,512],[1063,512],[1093,513],[1064,512],[1065,512],[1066,512],[1067,512],[1068,512],[1069,512],[1070,512],[1071,512],[1072,512],[1073,512],[1074,512],[1075,512],[1076,512],[1078,512],[1077,512],[1079,512],[1080,512],[1081,512],[1082,512],[1083,512],[1084,512],[1085,512],[1086,512],[1087,512],[1088,512],[1089,512],[1092,512],[1090,512],[1091,512],[1309,514],[1315,515],[1313,516],[1311,516],[1314,516],[1310,516],[1312,516],[1308,516],[1323,9],[1324,517],[1307,9],[1322,9],[510,12],[1349,518],[1468,519],[1334,520],[1501,521],[1472,522],[1502,523],[1470,524],[1344,525],[1346,526],[1526,527],[1347,528],[1529,521],[1528,522],[1530,523],[1527,524],[1326,520],[1331,529],[1534,530],[1332,528],[1333,531],[1536,532],[520,533],[521,533],[522,533],[523,533],[524,533],[525,533],[528,534],[527,534],[1533,535],[1535,536],[1467,537],[1466,538],[568,539],[570,540],[559,541],[567,542],[569,543],[565,544],[558,545],[1348,546],[1524,546],[1190,547],[1493,548],[1538,549],[1540,550],[1539,551],[1028,552],[1030,553],[1024,554],[578,555],[1029,556],[1031,557],[579,558],[577,559],[1035,560],[1033,561],[1034,561],[1032,562],[1541,563],[572,564],[1537,565],[1471,566],[1496,567],[1499,568],[1036,9],[1146,569],[1145,570],[1495,571],[1154,572],[1147,573],[1153,574],[1149,575],[1150,576],[1152,577],[1151,578],[1148,579],[1155,580],[1144,581],[1143,582],[1142,581],[1500,583],[1110,584],[1494,585],[1542,586],[1469,587],[1525,588],[1175,589],[1169,590],[1167,591],[1170,592],[1520,593],[1513,594],[1505,595],[1508,596],[1523,597],[1522,597],[1519,598],[1517,599],[1512,600],[1515,601],[1514,593],[1516,602],[1521,603],[1511,604],[1518,605],[1181,606],[1179,607],[1176,608],[1177,609],[1173,610],[1174,609],[1180,611],[1178,609],[1182,612],[1191,613],[1193,614],[1183,615],[1192,616],[1156,9],[1172,9],[1489,617],[1531,618],[1341,619],[1504,545],[1503,37],[1532,620],[1510,621],[1488,622],[1168,623],[543,624],[1013,625],[534,626],[1350,37],[539,627],[1498,628],[1189,629],[1507,630],[1340,631],[1543,632],[566,633],[576,634],[1345,37],[1023,635],[1546,636],[557,637],[1335,638],[1492,639],[1027,640],[532,633],[564,641],[573,633],[1549,642],[533,643],[1188,644],[1550,37],[1551,37],[1552,37],[1553,37],[1554,37],[1555,37],[1556,37],[1557,37],[1558,37],[1157,37],[1166,645],[1343,646],[1330,37],[1194,531],[1195,37],[1196,37],[517,9],[1300,647],[1342,648],[1161,9],[518,9],[1301,9],[1302,649],[1162,9],[1164,650],[1303,651],[1163,9],[1305,652],[526,533],[1165,653],[1306,9],[1159,654],[1158,9],[531,643],[1317,655],[1109,656],[1318,657],[519,658],[1319,659],[1316,660],[1320,659],[1321,661],[1325,662],[1160,9],[571,9],[1304,564]],"semanticDiagnosticsPerFile":[[568,[{"start":11593,"length":10,"code":2322,"category":1,"messageText":{"messageText":"Type '{} | undefined' is not assignable to type 'ReactNode'.","category":1,"code":2322,"next":[{"messageText":"Type '{}' is not assignable to type 'ReactNode'.","category":1,"code":2322}]},"relatedInformation":[{"file":"./node_modules/@types/react/index.d.ts","start":84233,"length":8,"messageText":"The expected type comes from property 'children' which is declared here on type 'DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>'","category":3,"code":6500}]}]],[570,[{"start":322,"length":9,"messageText":"Cannot find name 'DataTable'.","category":1,"code":2304}]],[1030,[{"start":14179,"length":24,"code":2352,"category":1,"messageText":{"messageText":"Conversion of type 'string | number | boolean | File | File[] | null | undefined' to type 'BendingDetail[]' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first.","category":1,"code":2352,"next":[{"messageText":"Type 'File[]' is not comparable to type 'BendingDetail[]'.","category":1,"code":2678,"next":[{"messageText":"Type 'File' is missing the following properties from type 'BendingDetail': id, no, input, elongation, and 3 more.","category":1,"code":2740,"canonicalHead":{"code":2678,"messageText":"Type 'File' is not comparable to type 'BendingDetail'."}}]}]}},{"start":14488,"length":18,"code":2352,"category":1,"messageText":{"messageText":"Conversion of type 'string | number | boolean | File | File[] | null | undefined' to type 'BOMLine[]' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first.","category":1,"code":2352,"next":[{"messageText":"Type 'File[]' is not comparable to type 'BOMLine[]'.","category":1,"code":2678,"next":[{"messageText":"Type 'File' is missing the following properties from type 'BOMLine': id, childItemCode, childItemName, quantity, unit","category":1,"code":2739,"canonicalHead":{"code":2678,"messageText":"Type 'File' is not comparable to type 'BOMLine'."}}]}]}}]],[1109,[{"start":629,"length":4,"code":2769,"category":1,"messageText":{"messageText":"No overload matches this call.","category":1,"code":2769,"next":[{"messageText":"Overload 1 of 2, '(values: readonly [\"FG\", \"PT\", \"SM\", \"RM\", \"CS\"], params?: string | { error?: string | $ZodErrorMap<$ZodIssueInvalidValue<unknown>> | undefined; message?: string | undefined; } | undefined): ZodEnum<...>', gave the following error.","category":1,"code":2772,"next":[{"messageText":"Object literal may only specify known properties, and 'errorMap' does not exist in type '{ error?: string | $ZodErrorMap<$ZodIssueInvalidValue<unknown>> | undefined; message?: string | undefined; }'.","category":1,"code":2353}]},{"messageText":"Overload 2 of 2, '(entries: Readonly<Record<string, EnumValue>>, params?: string | { error?: string | $ZodErrorMap<$ZodIssueInvalidValue<unknown>> | undefined; message?: string | undefined; } | undefined): ZodEnum<...>', gave the following error.","category":1,"code":2772,"next":[{"messageText":"Argument of type 'string[]' is not assignable to parameter of type 'Readonly<Record<string, EnumValue>>'.","category":1,"code":2345,"next":[{"messageText":"Index signature for type 'string' is missing in type 'string[]'.","category":1,"code":2329}]}]}]},"relatedInformation":[]}]],[1148,[{"start":2088,"length":11,"code":2339,"category":1,"messageText":{"messageText":"Property 'productName' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'productName' does not exist on type 'Partial<FieldErrorsImpl<{ partType: string; isActive: boolean; currentRevision: number; isFinal: boolean; itemType: \"PT\"; length: string; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 42 more ...; chainSpec: string; }>> & { ......'.","category":1,"code":2339}]}},{"start":2152,"length":11,"code":2339,"category":1,"messageText":{"messageText":"Property 'productName' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'productName' does not exist on type 'Partial<FieldErrorsImpl<{ partType: string; isActive: boolean; currentRevision: number; isFinal: boolean; itemType: \"PT\"; length: string; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 42 more ...; chainSpec: string; }>> & { ......'.","category":1,"code":2339}]}},{"start":2241,"length":11,"code":2339,"category":1,"messageText":{"messageText":"Property 'productName' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'productName' does not exist on type 'Partial<FieldErrorsImpl<{ partType: string; isActive: boolean; currentRevision: number; isFinal: boolean; itemType: \"PT\"; length: string; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 42 more ...; chainSpec: string; }>> & { ......'.","category":1,"code":2339}]}},{"start":2305,"length":11,"code":2339,"category":1,"messageText":{"messageText":"Property 'productName' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'productName' does not exist on type 'Partial<FieldErrorsImpl<{ partType: string; isActive: boolean; currentRevision: number; isFinal: boolean; itemType: \"PT\"; length: string; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 42 more ...; chainSpec: string; }>> & { ......'.","category":1,"code":2339}]}}]],[1150,[{"start":4143,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'material' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'material' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":4640,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'material' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'material' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":4734,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'material' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'material' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":5407,"length":6,"code":2339,"category":1,"messageText":{"messageText":"Property 'length' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'length' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":5569,"length":6,"code":2339,"category":1,"messageText":{"messageText":"Property 'length' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'length' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":5661,"length":6,"code":2339,"category":1,"messageText":{"messageText":"Property 'length' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'length' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":5732,"length":6,"code":2339,"category":1,"messageText":{"messageText":"Property 'length' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'length' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":6307,"length":13,"code":2339,"category":1,"messageText":{"messageText":"Property 'bendingLength' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'bendingLength' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":7304,"length":13,"code":2339,"category":1,"messageText":{"messageText":"Property 'bendingLength' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'bendingLength' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":7403,"length":13,"code":2339,"category":1,"messageText":{"messageText":"Property 'bendingLength' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'bendingLength' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}}]],[1151,[{"start":3087,"length":19,"code":2339,"category":1,"messageText":{"messageText":"Property 'electricOpenerPower' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'electricOpenerPower' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":3441,"length":19,"code":2339,"category":1,"messageText":{"messageText":"Property 'electricOpenerPower' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'electricOpenerPower' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":3546,"length":19,"code":2339,"category":1,"messageText":{"messageText":"Property 'electricOpenerPower' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'electricOpenerPower' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":4034,"length":22,"code":2339,"category":1,"messageText":{"messageText":"Property 'electricOpenerCapacity' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'electricOpenerCapacity' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":4695,"length":22,"code":2339,"category":1,"messageText":{"messageText":"Property 'electricOpenerCapacity' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'electricOpenerCapacity' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":4803,"length":22,"code":2339,"category":1,"messageText":{"messageText":"Property 'electricOpenerCapacity' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'electricOpenerCapacity' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":5544,"length":12,"code":2339,"category":1,"messageText":{"messageText":"Property 'motorVoltage' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'motorVoltage' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":5889,"length":12,"code":2339,"category":1,"messageText":{"messageText":"Property 'motorVoltage' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'motorVoltage' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":5987,"length":12,"code":2339,"category":1,"messageText":{"messageText":"Property 'motorVoltage' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'motorVoltage' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":6572,"length":9,"code":2339,"category":1,"messageText":{"messageText":"Property 'chainSpec' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'chainSpec' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":7018,"length":9,"code":2339,"category":1,"messageText":{"messageText":"Property 'chainSpec' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'chainSpec' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":7113,"length":9,"code":2339,"category":1,"messageText":{"messageText":"Property 'chainSpec' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'chainSpec' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}}]],[1153,[{"start":4704,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'partType' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'partType' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":5146,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'partType' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'partType' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":5232,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'partType' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'partType' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}},{"start":5293,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'partType' does not exist on type 'FieldErrors<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy...'.","category":1,"code":2339,"next":[{"messageText":"Property 'partType' does not exist on type 'Partial<FieldErrorsImpl<{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 22 more ...; finalizedBy: string; }>> ...'.","category":1,"code":2339}]}}]],[1305,[{"start":821,"length":24,"code":7053,"category":1,"messageText":{"messageText":"Element implicitly has an 'any' type because expression of type '\"Authorization\"' can't be used to index type 'HeadersInit'.","category":1,"code":7053,"next":[{"messageText":"Property 'Authorization' does not exist on type 'HeadersInit'.","category":1,"code":2339}]}}]],[1325,[{"start":7708,"length":11,"code":2769,"category":1,"messageText":{"messageText":"No overload matches this call.","category":1,"code":2769,"next":[{"messageText":"Overload 1 of 2, '(partial: MasterDataStore | Partial<MasterDataStore> | ((state: MasterDataStore) => MasterDataStore | Partial<...>), replace?: false | undefined, action?: Action | undefined): void', gave the following error.","category":1,"code":2772,"next":[{"messageText":"Type '{}' is missing the following properties from type 'Record<PageType, PageConfig | null>': \"item-master\", quotation, \"sales-order\", formula, pricing","category":1,"code":2739,"canonicalHead":{"code":2322,"messageText":"Type '{}' is not assignable to type 'Record<PageType, PageConfig | null>'."}}]},{"messageText":"Overload 2 of 2, '(state: MasterDataStore | ((state: MasterDataStore) => MasterDataStore), replace: true, action?: Action | undefined): void', gave the following error.","category":1,"code":2772,"next":[{"messageText":"Type '{}' is missing the following properties from type 'Record<PageType, PageConfig | null>': \"item-master\", quotation, \"sales-order\", formula, pricing","category":1,"code":2739,"canonicalHead":{"code":2322,"messageText":"Type '{}' is not assignable to type 'Record<PageType, PageConfig | null>'."}}]}]},"relatedInformation":[]},{"start":10569,"length":7,"messageText":"Expected 0-1 arguments, but got 2.","category":1,"code":2554}]],[1542,[{"start":4414,"length":15,"code":2339,"category":1,"messageText":{"messageText":"Property 'productCategory' does not exist on type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...'.","category":1,"code":2339,"next":[{"messageText":"Property 'productCategory' does not exist on type '{ partType: string; isActive: boolean; currentRevision: number; isFinal: boolean; itemType: \"PT\"; length?: string | undefined; bom?: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 42 more ...; chainSpec?: string | undefined; }'.","category":1,"code":2339}]}},{"start":4462,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'partType' does not exist on type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...'.","category":1,"code":2339,"next":[{"messageText":"Property 'partType' does not exist on type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...'.","category":1,"code":2339}]}},{"start":4502,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'material' does not exist on type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...'.","category":1,"code":2339,"next":[{"messageText":"Property 'material' does not exist on type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...'.","category":1,"code":2339}]}},{"start":4545,"length":10,"code":2339,"category":1,"messageText":{"messageText":"Property 'salesPrice' does not exist on type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...'.","category":1,"code":2339,"next":[{"messageText":"Property 'salesPrice' does not exist on type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...'.","category":1,"code":2339}]}},{"start":4593,"length":13,"code":2339,"category":1,"messageText":{"messageText":"Property 'purchasePrice' does not exist on type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...'.","category":1,"code":2339,"next":[{"messageText":"Property 'purchasePrice' does not exist on type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...'.","category":1,"code":2339}]}},{"start":4695,"length":19,"code":2339,"category":1,"messageText":{"messageText":"Property 'certificationNumber' does not exist on type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...'.","category":1,"code":2339,"next":[{"messageText":"Property 'certificationNumber' does not exist on type '{ unit: string; itemName: string; specification: string; isActive: boolean; currentRevision: number; isFinal: boolean; itemType: \"SM\"; length?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 16 more ...; finalizedBy?: strin...'.","category":1,"code":2339}]}},{"start":4762,"length":22,"code":2339,"category":1,"messageText":{"messageText":"Property 'certificationStartDate' does not exist on type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...'.","category":1,"code":2339,"next":[{"messageText":"Property 'certificationStartDate' does not exist on type '{ unit: string; itemName: string; specification: string; isActive: boolean; currentRevision: number; isFinal: boolean; itemType: \"SM\"; length?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 16 more ...; finalizedBy?: strin...'.","category":1,"code":2339}]}},{"start":4830,"length":20,"code":2339,"category":1,"messageText":{"messageText":"Property 'certificationEndDate' does not exist on type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...'.","category":1,"code":2339,"next":[{"messageText":"Property 'certificationEndDate' does not exist on type '{ unit: string; itemName: string; specification: string; isActive: boolean; currentRevision: number; isFinal: boolean; itemType: \"SM\"; length?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 16 more ...; finalizedBy?: strin...'.","category":1,"code":2339}]}},{"start":6145,"length":11,"code":2322,"category":1,"messageText":{"messageText":"Type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...' is not assignable to type 'ItemMaster | undefined'.","category":1,"code":2322,"next":[{"messageText":"Type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...' is missing the following properties from type 'ItemMaster': id, createdAt","category":1,"code":2739,"canonicalHead":{"code":2322,"messageText":"Type '{ itemName: string; isActive: boolean; currentRevision: number; isFinal: boolean; productName: string; itemType: \"FG\"; bom?: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 22 more ...; finalizedBy?: string | ...' is not assignable to type 'ItemMaster'."}}]},"relatedInformation":[{"file":"./src/components/items/itemform/types.ts","start":204,"length":11,"messageText":"The expected type comes from property 'initialData' which is declared here on type 'IntrinsicAttributes & ItemFormProps'","category":3,"code":6500}]}]]],"affectedFilesPendingEmit":[1564,1563,1565,1566,1562,1567,1568,1561,511,502,510,1349,1468,1334,1501,1472,1502,1470,1344,1346,1526,1347,1529,1528,1530,1527,1326,1331,1534,1332,1333,1536,520,521,522,523,524,525,528,527,1533,1535,1467,1466,568,570,559,567,569,565,558,1348,1524,1190,1493,1538,1540,1539,1028,1030,1024,578,1029,1031,579,577,1035,1033,1034,1032,1541,572,1537,1471,1496,1499,1036,1146,1145,1495,1154,1147,1153,1149,1150,1152,1151,1148,1155,1144,1143,1142,1500,1110,1494,1542,1469,1525,1175,1169,1167,1170,1520,1513,1505,1508,1523,1522,1519,1517,1512,1515,1514,1516,1521,1511,1518,1181,1179,1176,1177,1173,1174,1180,1178,1182,1191,1193,1183,1192,1156,1172,1489,1531,1341,1504,1503,1532,1510,1488,1168,543,1013,534,1350,539,1498,1189,1507,1340,1543,566,576,1345,1023,1546,557,1335,1492,1027,532,564,573,1549,533,1188,1550,1551,1552,1553,1554,1555,1556,1557,1558,1157,1166,1343,1330,1194,1195,1196,517,1300,1342,1161,518,1301,1302,1162,1164,1303,1163,1305,526,1165,1306,1159,1158,531,1317,1109,1318,519,1319,1316,1320,1321,1325,1160,571,1304],"version":"5.9.3"}
\ No newline at end of file
+{"fileNames":["./node_modules/typescript/lib/lib.es5.d.ts","./node_modules/typescript/lib/lib.es2015.d.ts","./node_modules/typescript/lib/lib.es2016.d.ts","./node_modules/typescript/lib/lib.es2017.d.ts","./node_modules/typescript/lib/lib.es2018.d.ts","./node_modules/typescript/lib/lib.es2019.d.ts","./node_modules/typescript/lib/lib.es2020.d.ts","./node_modules/typescript/lib/lib.es2021.d.ts","./node_modules/typescript/lib/lib.es2022.d.ts","./node_modules/typescript/lib/lib.es2023.d.ts","./node_modules/typescript/lib/lib.es2024.d.ts","./node_modules/typescript/lib/lib.esnext.d.ts","./node_modules/typescript/lib/lib.dom.d.ts","./node_modules/typescript/lib/lib.dom.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.core.d.ts","./node_modules/typescript/lib/lib.es2015.collection.d.ts","./node_modules/typescript/lib/lib.es2015.generator.d.ts","./node_modules/typescript/lib/lib.es2015.iterable.d.ts","./node_modules/typescript/lib/lib.es2015.promise.d.ts","./node_modules/typescript/lib/lib.es2015.proxy.d.ts","./node_modules/typescript/lib/lib.es2015.reflect.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.d.ts","./node_modules/typescript/lib/lib.es2015.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2016.array.include.d.ts","./node_modules/typescript/lib/lib.es2016.intl.d.ts","./node_modules/typescript/lib/lib.es2017.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2017.date.d.ts","./node_modules/typescript/lib/lib.es2017.object.d.ts","./node_modules/typescript/lib/lib.es2017.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2017.string.d.ts","./node_modules/typescript/lib/lib.es2017.intl.d.ts","./node_modules/typescript/lib/lib.es2017.typedarrays.d.ts","./node_modules/typescript/lib/lib.es2018.asyncgenerator.d.ts","./node_modules/typescript/lib/lib.es2018.asynciterable.d.ts","./node_modules/typescript/lib/lib.es2018.intl.d.ts","./node_modules/typescript/lib/lib.es2018.promise.d.ts","./node_modules/typescript/lib/lib.es2018.regexp.d.ts","./node_modules/typescript/lib/lib.es2019.array.d.ts","./node_modules/typescript/lib/lib.es2019.object.d.ts","./node_modules/typescript/lib/lib.es2019.string.d.ts","./node_modules/typescript/lib/lib.es2019.symbol.d.ts","./node_modules/typescript/lib/lib.es2019.intl.d.ts","./node_modules/typescript/lib/lib.es2020.bigint.d.ts","./node_modules/typescript/lib/lib.es2020.date.d.ts","./node_modules/typescript/lib/lib.es2020.promise.d.ts","./node_modules/typescript/lib/lib.es2020.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2020.string.d.ts","./node_modules/typescript/lib/lib.es2020.symbol.wellknown.d.ts","./node_modules/typescript/lib/lib.es2020.intl.d.ts","./node_modules/typescript/lib/lib.es2020.number.d.ts","./node_modules/typescript/lib/lib.es2021.promise.d.ts","./node_modules/typescript/lib/lib.es2021.string.d.ts","./node_modules/typescript/lib/lib.es2021.weakref.d.ts","./node_modules/typescript/lib/lib.es2021.intl.d.ts","./node_modules/typescript/lib/lib.es2022.array.d.ts","./node_modules/typescript/lib/lib.es2022.error.d.ts","./node_modules/typescript/lib/lib.es2022.intl.d.ts","./node_modules/typescript/lib/lib.es2022.object.d.ts","./node_modules/typescript/lib/lib.es2022.string.d.ts","./node_modules/typescript/lib/lib.es2022.regexp.d.ts","./node_modules/typescript/lib/lib.es2023.array.d.ts","./node_modules/typescript/lib/lib.es2023.collection.d.ts","./node_modules/typescript/lib/lib.es2023.intl.d.ts","./node_modules/typescript/lib/lib.es2024.arraybuffer.d.ts","./node_modules/typescript/lib/lib.es2024.collection.d.ts","./node_modules/typescript/lib/lib.es2024.object.d.ts","./node_modules/typescript/lib/lib.es2024.promise.d.ts","./node_modules/typescript/lib/lib.es2024.regexp.d.ts","./node_modules/typescript/lib/lib.es2024.sharedmemory.d.ts","./node_modules/typescript/lib/lib.es2024.string.d.ts","./node_modules/typescript/lib/lib.esnext.array.d.ts","./node_modules/typescript/lib/lib.esnext.collection.d.ts","./node_modules/typescript/lib/lib.esnext.intl.d.ts","./node_modules/typescript/lib/lib.esnext.disposable.d.ts","./node_modules/typescript/lib/lib.esnext.promise.d.ts","./node_modules/typescript/lib/lib.esnext.decorators.d.ts","./node_modules/typescript/lib/lib.esnext.iterator.d.ts","./node_modules/typescript/lib/lib.esnext.float16.d.ts","./node_modules/typescript/lib/lib.esnext.error.d.ts","./node_modules/typescript/lib/lib.esnext.sharedmemory.d.ts","./node_modules/typescript/lib/lib.decorators.d.ts","./node_modules/typescript/lib/lib.decorators.legacy.d.ts","./.next/types/routes.d.ts","./node_modules/@types/react/global.d.ts","./node_modules/csstype/index.d.ts","./node_modules/@types/react/index.d.ts","./node_modules/next/dist/styled-jsx/types/css.d.ts","./node_modules/next/dist/styled-jsx/types/macro.d.ts","./node_modules/next/dist/styled-jsx/types/style.d.ts","./node_modules/next/dist/styled-jsx/types/global.d.ts","./node_modules/next/dist/styled-jsx/types/index.d.ts","./node_modules/next/dist/shared/lib/amp.d.ts","./node_modules/next/amp.d.ts","./node_modules/next/dist/server/get-page-files.d.ts","./node_modules/@types/node/compatibility/disposable.d.ts","./node_modules/@types/node/compatibility/indexable.d.ts","./node_modules/@types/node/compatibility/iterators.d.ts","./node_modules/@types/node/compatibility/index.d.ts","./node_modules/@types/node/globals.typedarray.d.ts","./node_modules/@types/node/buffer.buffer.d.ts","./node_modules/@types/node/globals.d.ts","./node_modules/@types/node/web-globals/abortcontroller.d.ts","./node_modules/@types/node/web-globals/domexception.d.ts","./node_modules/@types/node/web-globals/events.d.ts","./node_modules/undici-types/header.d.ts","./node_modules/undici-types/readable.d.ts","./node_modules/undici-types/file.d.ts","./node_modules/undici-types/fetch.d.ts","./node_modules/undici-types/formdata.d.ts","./node_modules/undici-types/connector.d.ts","./node_modules/undici-types/client.d.ts","./node_modules/undici-types/errors.d.ts","./node_modules/undici-types/dispatcher.d.ts","./node_modules/undici-types/global-dispatcher.d.ts","./node_modules/undici-types/global-origin.d.ts","./node_modules/undici-types/pool-stats.d.ts","./node_modules/undici-types/pool.d.ts","./node_modules/undici-types/handlers.d.ts","./node_modules/undici-types/balanced-pool.d.ts","./node_modules/undici-types/agent.d.ts","./node_modules/undici-types/mock-interceptor.d.ts","./node_modules/undici-types/mock-agent.d.ts","./node_modules/undici-types/mock-client.d.ts","./node_modules/undici-types/mock-pool.d.ts","./node_modules/undici-types/mock-errors.d.ts","./node_modules/undici-types/proxy-agent.d.ts","./node_modules/undici-types/env-http-proxy-agent.d.ts","./node_modules/undici-types/retry-handler.d.ts","./node_modules/undici-types/retry-agent.d.ts","./node_modules/undici-types/api.d.ts","./node_modules/undici-types/interceptors.d.ts","./node_modules/undici-types/util.d.ts","./node_modules/undici-types/cookies.d.ts","./node_modules/undici-types/patch.d.ts","./node_modules/undici-types/websocket.d.ts","./node_modules/undici-types/eventsource.d.ts","./node_modules/undici-types/filereader.d.ts","./node_modules/undici-types/diagnostics-channel.d.ts","./node_modules/undici-types/content-type.d.ts","./node_modules/undici-types/cache.d.ts","./node_modules/undici-types/index.d.ts","./node_modules/@types/node/web-globals/fetch.d.ts","./node_modules/@types/node/assert.d.ts","./node_modules/@types/node/assert/strict.d.ts","./node_modules/@types/node/async_hooks.d.ts","./node_modules/@types/node/buffer.d.ts","./node_modules/@types/node/child_process.d.ts","./node_modules/@types/node/cluster.d.ts","./node_modules/@types/node/console.d.ts","./node_modules/@types/node/constants.d.ts","./node_modules/@types/node/crypto.d.ts","./node_modules/@types/node/dgram.d.ts","./node_modules/@types/node/diagnostics_channel.d.ts","./node_modules/@types/node/dns.d.ts","./node_modules/@types/node/dns/promises.d.ts","./node_modules/@types/node/domain.d.ts","./node_modules/@types/node/events.d.ts","./node_modules/@types/node/fs.d.ts","./node_modules/@types/node/fs/promises.d.ts","./node_modules/@types/node/http.d.ts","./node_modules/@types/node/http2.d.ts","./node_modules/@types/node/https.d.ts","./node_modules/@types/node/inspector.generated.d.ts","./node_modules/@types/node/module.d.ts","./node_modules/@types/node/net.d.ts","./node_modules/@types/node/os.d.ts","./node_modules/@types/node/path.d.ts","./node_modules/@types/node/perf_hooks.d.ts","./node_modules/@types/node/process.d.ts","./node_modules/@types/node/punycode.d.ts","./node_modules/@types/node/querystring.d.ts","./node_modules/@types/node/readline.d.ts","./node_modules/@types/node/readline/promises.d.ts","./node_modules/@types/node/repl.d.ts","./node_modules/@types/node/sea.d.ts","./node_modules/@types/node/stream.d.ts","./node_modules/@types/node/stream/promises.d.ts","./node_modules/@types/node/stream/consumers.d.ts","./node_modules/@types/node/stream/web.d.ts","./node_modules/@types/node/string_decoder.d.ts","./node_modules/@types/node/test.d.ts","./node_modules/@types/node/timers.d.ts","./node_modules/@types/node/timers/promises.d.ts","./node_modules/@types/node/tls.d.ts","./node_modules/@types/node/trace_events.d.ts","./node_modules/@types/node/tty.d.ts","./node_modules/@types/node/url.d.ts","./node_modules/@types/node/util.d.ts","./node_modules/@types/node/v8.d.ts","./node_modules/@types/node/vm.d.ts","./node_modules/@types/node/wasi.d.ts","./node_modules/@types/node/worker_threads.d.ts","./node_modules/@types/node/zlib.d.ts","./node_modules/@types/node/index.d.ts","./node_modules/@types/react/canary.d.ts","./node_modules/@types/react/experimental.d.ts","./node_modules/@types/react-dom/index.d.ts","./node_modules/@types/react-dom/canary.d.ts","./node_modules/@types/react-dom/experimental.d.ts","./node_modules/next/dist/lib/fallback.d.ts","./node_modules/next/dist/compiled/webpack/webpack.d.ts","./node_modules/next/dist/server/config.d.ts","./node_modules/next/dist/lib/load-custom-routes.d.ts","./node_modules/next/dist/shared/lib/image-config.d.ts","./node_modules/next/dist/build/webpack/plugins/subresource-integrity-plugin.d.ts","./node_modules/next/dist/server/body-streams.d.ts","./node_modules/next/dist/server/lib/cache-control.d.ts","./node_modules/next/dist/lib/setup-exception-listeners.d.ts","./node_modules/next/dist/lib/worker.d.ts","./node_modules/next/dist/lib/constants.d.ts","./node_modules/next/dist/client/components/app-router-headers.d.ts","./node_modules/next/dist/build/rendering-mode.d.ts","./node_modules/next/dist/server/lib/router-utils/build-prefetch-segment-data-route.d.ts","./node_modules/next/dist/server/require-hook.d.ts","./node_modules/next/dist/server/lib/experimental/ppr.d.ts","./node_modules/next/dist/build/webpack/plugins/app-build-manifest-plugin.d.ts","./node_modules/next/dist/lib/page-types.d.ts","./node_modules/next/dist/build/segment-config/app/app-segment-config.d.ts","./node_modules/next/dist/build/segment-config/pages/pages-segment-config.d.ts","./node_modules/next/dist/build/analysis/get-page-static-info.d.ts","./node_modules/next/dist/build/webpack/loaders/get-module-build-info.d.ts","./node_modules/next/dist/build/webpack/plugins/middleware-plugin.d.ts","./node_modules/next/dist/server/node-polyfill-crypto.d.ts","./node_modules/next/dist/server/node-environment-baseline.d.ts","./node_modules/next/dist/server/node-environment-extensions/error-inspect.d.ts","./node_modules/next/dist/server/node-environment-extensions/random.d.ts","./node_modules/next/dist/server/node-environment-extensions/date.d.ts","./node_modules/next/dist/server/node-environment-extensions/web-crypto.d.ts","./node_modules/next/dist/server/node-environment-extensions/node-crypto.d.ts","./node_modules/next/dist/server/node-environment.d.ts","./node_modules/next/dist/build/page-extensions-type.d.ts","./node_modules/next/dist/build/webpack/plugins/flight-manifest-plugin.d.ts","./node_modules/next/dist/server/instrumentation/types.d.ts","./node_modules/next/dist/lib/coalesced-function.d.ts","./node_modules/next/dist/shared/lib/router/utils/middleware-route-matcher.d.ts","./node_modules/next/dist/server/lib/router-utils/types.d.ts","./node_modules/next/dist/shared/lib/modern-browserslist-target.d.ts","./node_modules/next/dist/shared/lib/constants.d.ts","./node_modules/next/dist/trace/types.d.ts","./node_modules/next/dist/trace/trace.d.ts","./node_modules/next/dist/trace/shared.d.ts","./node_modules/next/dist/trace/index.d.ts","./node_modules/next/dist/build/load-jsconfig.d.ts","./node_modules/@next/env/dist/index.d.ts","./node_modules/next/dist/build/webpack/plugins/telemetry-plugin/use-cache-tracker-utils.d.ts","./node_modules/next/dist/build/webpack/plugins/telemetry-plugin/telemetry-plugin.d.ts","./node_modules/next/dist/telemetry/storage.d.ts","./node_modules/next/dist/build/build-context.d.ts","./node_modules/next/dist/shared/lib/bloom-filter.d.ts","./node_modules/next/dist/build/webpack-config.d.ts","./node_modules/next/dist/server/route-kind.d.ts","./node_modules/next/dist/server/route-definitions/route-definition.d.ts","./node_modules/next/dist/build/swc/generated-native.d.ts","./node_modules/next/dist/build/swc/types.d.ts","./node_modules/next/dist/server/dev/parse-version-info.d.ts","./node_modules/next/dist/next-devtools/shared/types.d.ts","./node_modules/next/dist/server/dev/dev-indicator-server-state.d.ts","./node_modules/next/dist/server/lib/parse-stack.d.ts","./node_modules/next/dist/next-devtools/server/shared.d.ts","./node_modules/next/dist/next-devtools/shared/stack-frame.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/utils/get-error-by-type.d.ts","./node_modules/@types/react/jsx-runtime.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/container/runtime-error/render-error.d.ts","./node_modules/next/dist/next-devtools/dev-overlay/shared.d.ts","./node_modules/next/dist/server/dev/hot-reloader-types.d.ts","./node_modules/next/dist/server/lib/cache-handlers/types.d.ts","./node_modules/next/dist/server/response-cache/types.d.ts","./node_modules/next/dist/server/resume-data-cache/cache-store.d.ts","./node_modules/next/dist/server/resume-data-cache/resume-data-cache.d.ts","./node_modules/next/dist/server/render-result.d.ts","./node_modules/next/dist/server/lib/i18n-provider.d.ts","./node_modules/next/dist/server/web/next-url.d.ts","./node_modules/next/dist/compiled/@edge-runtime/cookies/index.d.ts","./node_modules/next/dist/server/web/spec-extension/cookies.d.ts","./node_modules/next/dist/server/web/spec-extension/request.d.ts","./node_modules/next/dist/server/after/builtin-request-context.d.ts","./node_modules/next/dist/server/web/spec-extension/fetch-event.d.ts","./node_modules/next/dist/server/web/spec-extension/response.d.ts","./node_modules/next/dist/build/segment-config/middleware/middleware-config.d.ts","./node_modules/next/dist/server/web/types.d.ts","./node_modules/next/dist/build/webpack/plugins/pages-manifest-plugin.d.ts","./node_modules/next/dist/shared/lib/router/utils/parse-url.d.ts","./node_modules/next/dist/server/base-http/node.d.ts","./node_modules/next/dist/build/webpack/plugins/next-font-manifest-plugin.d.ts","./node_modules/next/dist/server/route-definitions/locale-route-definition.d.ts","./node_modules/next/dist/server/route-definitions/pages-route-definition.d.ts","./node_modules/next/dist/shared/lib/mitt.d.ts","./node_modules/next/dist/client/with-router.d.ts","./node_modules/next/dist/client/router.d.ts","./node_modules/next/dist/client/route-loader.d.ts","./node_modules/next/dist/client/page-loader.d.ts","./node_modules/next/dist/shared/lib/router/router.d.ts","./node_modules/next/dist/shared/lib/router-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/loadable-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/loadable.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/image-config-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/head-manager-context.shared-runtime.d.ts","./node_modules/next/dist/server/route-definitions/app-page-route-definition.d.ts","./node_modules/next/dist/build/webpack/loaders/metadata/types.d.ts","./node_modules/next/dist/build/webpack/loaders/next-app-loader/index.d.ts","./node_modules/next/dist/server/lib/app-dir-module.d.ts","./node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.d.ts","./node_modules/next/dist/server/async-storage/draft-mode-provider.d.ts","./node_modules/next/dist/server/web/spec-extension/adapters/headers.d.ts","./node_modules/next/dist/server/app-render/cache-signal.d.ts","./node_modules/next/dist/server/app-render/dynamic-rendering.d.ts","./node_modules/next/dist/server/request/fallback-params.d.ts","./node_modules/next/dist/server/app-render/work-unit-async-storage-instance.d.ts","./node_modules/next/dist/server/response-cache/index.d.ts","./node_modules/next/dist/server/lib/lazy-result.d.ts","./node_modules/next/dist/server/lib/implicit-tags.d.ts","./node_modules/next/dist/server/app-render/work-unit-async-storage.external.d.ts","./node_modules/next/dist/shared/lib/deep-readonly.d.ts","./node_modules/next/dist/shared/lib/router/utils/parse-relative-url.d.ts","./node_modules/next/dist/server/app-render/app-render.d.ts","./node_modules/next/dist/shared/lib/server-inserted-html.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/amp-context.shared-runtime.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/contexts/entrypoints.d.ts","./node_modules/next/dist/server/route-modules/app-page/module.compiled.d.ts","./node_modules/next/dist/client/components/error-boundary.d.ts","./node_modules/next/dist/client/components/layout-router.d.ts","./node_modules/next/dist/client/components/render-from-template-context.d.ts","./node_modules/next/dist/server/app-render/action-async-storage-instance.d.ts","./node_modules/next/dist/server/app-render/action-async-storage.external.d.ts","./node_modules/next/dist/client/components/client-page.d.ts","./node_modules/next/dist/client/components/client-segment.d.ts","./node_modules/next/dist/server/request/search-params.d.ts","./node_modules/next/dist/client/components/hooks-server-context.d.ts","./node_modules/next/dist/client/components/http-access-fallback/error-boundary.d.ts","./node_modules/next/dist/lib/metadata/types/alternative-urls-types.d.ts","./node_modules/next/dist/lib/metadata/types/extra-types.d.ts","./node_modules/next/dist/lib/metadata/types/metadata-types.d.ts","./node_modules/next/dist/lib/metadata/types/manifest-types.d.ts","./node_modules/next/dist/lib/metadata/types/opengraph-types.d.ts","./node_modules/next/dist/lib/metadata/types/twitter-types.d.ts","./node_modules/next/dist/lib/metadata/types/metadata-interface.d.ts","./node_modules/next/dist/lib/metadata/types/resolvers.d.ts","./node_modules/next/dist/lib/metadata/types/icons.d.ts","./node_modules/next/dist/lib/metadata/resolve-metadata.d.ts","./node_modules/next/dist/lib/metadata/metadata.d.ts","./node_modules/next/dist/lib/framework/boundary-components.d.ts","./node_modules/next/dist/server/app-render/rsc/preloads.d.ts","./node_modules/next/dist/server/app-render/rsc/postpone.d.ts","./node_modules/next/dist/server/app-render/rsc/taint.d.ts","./node_modules/next/dist/shared/lib/segment-cache/segment-value-encoding.d.ts","./node_modules/next/dist/server/app-render/collect-segment-data.d.ts","./node_modules/next/dist/next-devtools/userspace/app/segment-explorer-node.d.ts","./node_modules/next/dist/server/app-render/entry-base.d.ts","./node_modules/next/dist/build/templates/app-page.d.ts","./node_modules/@types/react/jsx-dev-runtime.d.ts","./node_modules/@types/react/compiler-runtime.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/rsc/entrypoints.d.ts","./node_modules/@types/react-dom/client.d.ts","./node_modules/@types/react-dom/static.d.ts","./node_modules/@types/react-dom/server.d.ts","./node_modules/next/dist/server/route-modules/app-page/vendored/ssr/entrypoints.d.ts","./node_modules/next/dist/server/route-modules/app-page/module.d.ts","./node_modules/next/dist/server/web/adapter.d.ts","./node_modules/next/dist/server/use-cache/cache-life.d.ts","./node_modules/next/dist/server/app-render/types.d.ts","./node_modules/next/dist/client/components/router-reducer/router-reducer-types.d.ts","./node_modules/next/dist/client/flight-data-helpers.d.ts","./node_modules/next/dist/client/components/router-reducer/fetch-server-response.d.ts","./node_modules/next/dist/shared/lib/app-router-context.shared-runtime.d.ts","./node_modules/next/dist/server/route-modules/pages/vendored/contexts/entrypoints.d.ts","./node_modules/next/dist/server/route-modules/pages/module.compiled.d.ts","./node_modules/next/dist/build/templates/pages.d.ts","./node_modules/next/dist/server/route-modules/pages/module.d.ts","./node_modules/next/dist/next-devtools/userspace/pages/pages-dev-overlay-setup.d.ts","./node_modules/next/dist/server/render.d.ts","./node_modules/next/dist/server/route-definitions/pages-api-route-definition.d.ts","./node_modules/next/dist/server/route-matches/pages-api-route-match.d.ts","./node_modules/next/dist/server/route-matchers/route-matcher.d.ts","./node_modules/next/dist/server/route-matcher-providers/route-matcher-provider.d.ts","./node_modules/next/dist/server/route-matcher-managers/route-matcher-manager.d.ts","./node_modules/next/dist/server/normalizers/normalizer.d.ts","./node_modules/next/dist/server/normalizers/locale-route-normalizer.d.ts","./node_modules/next/dist/server/normalizers/request/pathname-normalizer.d.ts","./node_modules/next/dist/server/normalizers/request/suffix.d.ts","./node_modules/next/dist/server/normalizers/request/rsc.d.ts","./node_modules/next/dist/server/normalizers/request/prefetch-rsc.d.ts","./node_modules/next/dist/server/normalizers/request/next-data.d.ts","./node_modules/next/dist/server/normalizers/request/segment-prefix-rsc.d.ts","./node_modules/next/dist/build/static-paths/types.d.ts","./node_modules/next/dist/server/base-server.d.ts","./node_modules/next/dist/server/lib/async-callback-set.d.ts","./node_modules/next/dist/shared/lib/router/utils/route-regex.d.ts","./node_modules/next/dist/shared/lib/router/utils/route-matcher.d.ts","./node_modules/sharp/lib/index.d.ts","./node_modules/next/dist/server/image-optimizer.d.ts","./node_modules/next/dist/server/next-server.d.ts","./node_modules/next/dist/server/lib/types.d.ts","./node_modules/next/dist/server/lib/lru-cache.d.ts","./node_modules/next/dist/server/lib/dev-bundler-service.d.ts","./node_modules/next/dist/server/dev/static-paths-worker.d.ts","./node_modules/next/dist/server/dev/next-dev-server.d.ts","./node_modules/next/dist/server/next.d.ts","./node_modules/next/dist/server/lib/render-server.d.ts","./node_modules/next/dist/server/lib/router-server.d.ts","./node_modules/next/dist/shared/lib/router/utils/path-match.d.ts","./node_modules/next/dist/server/lib/router-utils/filesystem.d.ts","./node_modules/next/dist/server/lib/router-utils/setup-dev-bundler.d.ts","./node_modules/next/dist/server/lib/router-utils/router-server-context.d.ts","./node_modules/next/dist/server/route-modules/route-module.d.ts","./node_modules/next/dist/server/load-components.d.ts","./node_modules/next/dist/server/route-definitions/app-route-route-definition.d.ts","./node_modules/next/dist/server/async-storage/work-store.d.ts","./node_modules/next/dist/server/web/http.d.ts","./node_modules/next/dist/server/route-modules/app-route/shared-modules.d.ts","./node_modules/next/dist/client/components/redirect-status-code.d.ts","./node_modules/next/dist/client/components/redirect-error.d.ts","./node_modules/next/dist/build/templates/app-route.d.ts","./node_modules/next/dist/server/route-modules/app-route/module.d.ts","./node_modules/next/dist/server/route-modules/app-route/module.compiled.d.ts","./node_modules/next/dist/build/segment-config/app/app-segments.d.ts","./node_modules/next/dist/build/utils.d.ts","./node_modules/next/dist/build/turborepo-access-trace/types.d.ts","./node_modules/next/dist/build/turborepo-access-trace/result.d.ts","./node_modules/next/dist/build/turborepo-access-trace/helpers.d.ts","./node_modules/next/dist/build/turborepo-access-trace/index.d.ts","./node_modules/next/dist/export/routes/types.d.ts","./node_modules/next/dist/export/types.d.ts","./node_modules/next/dist/export/worker.d.ts","./node_modules/next/dist/build/worker.d.ts","./node_modules/next/dist/build/index.d.ts","./node_modules/next/dist/server/lib/incremental-cache/index.d.ts","./node_modules/next/dist/server/after/after.d.ts","./node_modules/next/dist/server/after/after-context.d.ts","./node_modules/next/dist/server/app-render/work-async-storage-instance.d.ts","./node_modules/next/dist/server/app-render/work-async-storage.external.d.ts","./node_modules/next/dist/server/request/params.d.ts","./node_modules/next/dist/server/route-matches/route-match.d.ts","./node_modules/next/dist/server/request-meta.d.ts","./node_modules/next/dist/cli/next-test.d.ts","./node_modules/next/dist/server/config-shared.d.ts","./node_modules/next/dist/server/base-http/index.d.ts","./node_modules/next/dist/server/api-utils/index.d.ts","./node_modules/next/dist/types.d.ts","./node_modules/next/dist/shared/lib/html-context.shared-runtime.d.ts","./node_modules/next/dist/shared/lib/utils.d.ts","./node_modules/next/dist/pages/_app.d.ts","./node_modules/next/app.d.ts","./node_modules/next/dist/server/web/spec-extension/unstable-cache.d.ts","./node_modules/next/dist/server/web/spec-extension/revalidate.d.ts","./node_modules/next/dist/server/web/spec-extension/unstable-no-store.d.ts","./node_modules/next/dist/server/use-cache/cache-tag.d.ts","./node_modules/next/cache.d.ts","./node_modules/next/dist/shared/lib/runtime-config.external.d.ts","./node_modules/next/config.d.ts","./node_modules/next/dist/pages/_document.d.ts","./node_modules/next/document.d.ts","./node_modules/next/dist/shared/lib/dynamic.d.ts","./node_modules/next/dynamic.d.ts","./node_modules/next/dist/pages/_error.d.ts","./node_modules/next/error.d.ts","./node_modules/next/dist/shared/lib/head.d.ts","./node_modules/next/head.d.ts","./node_modules/next/dist/server/request/cookies.d.ts","./node_modules/next/dist/server/request/headers.d.ts","./node_modules/next/dist/server/request/draft-mode.d.ts","./node_modules/next/headers.d.ts","./node_modules/next/dist/shared/lib/get-img-props.d.ts","./node_modules/next/dist/client/image-component.d.ts","./node_modules/next/dist/shared/lib/image-external.d.ts","./node_modules/next/image.d.ts","./node_modules/next/dist/client/link.d.ts","./node_modules/next/link.d.ts","./node_modules/next/dist/client/components/redirect.d.ts","./node_modules/next/dist/client/components/not-found.d.ts","./node_modules/next/dist/client/components/forbidden.d.ts","./node_modules/next/dist/client/components/unauthorized.d.ts","./node_modules/next/dist/client/components/unstable-rethrow.server.d.ts","./node_modules/next/dist/client/components/unstable-rethrow.d.ts","./node_modules/next/dist/client/components/navigation.react-server.d.ts","./node_modules/next/dist/client/components/unrecognized-action-error.d.ts","./node_modules/next/dist/client/components/navigation.d.ts","./node_modules/next/navigation.d.ts","./node_modules/next/router.d.ts","./node_modules/next/dist/client/script.d.ts","./node_modules/next/script.d.ts","./node_modules/next/dist/server/web/spec-extension/user-agent.d.ts","./node_modules/next/dist/compiled/@edge-runtime/primitives/url.d.ts","./node_modules/next/dist/server/web/spec-extension/image-response.d.ts","./node_modules/next/dist/compiled/@vercel/og/satori/index.d.ts","./node_modules/next/dist/compiled/@vercel/og/emoji/index.d.ts","./node_modules/next/dist/compiled/@vercel/og/types.d.ts","./node_modules/next/dist/server/after/index.d.ts","./node_modules/next/dist/server/request/root-params.d.ts","./node_modules/next/dist/server/request/connection.d.ts","./node_modules/next/server.d.ts","./node_modules/next/types/global.d.ts","./node_modules/next/types/compiled.d.ts","./node_modules/next/types.d.ts","./node_modules/next/index.d.ts","./node_modules/next/image-types/global.d.ts","./next-env.d.ts","./node_modules/next-intl/dist/types/plugin/types.d.ts","./node_modules/next-intl/dist/types/plugin/createnextintlplugin.d.ts","./node_modules/next-intl/dist/types/plugin/index.d.ts","./node_modules/next-intl/dist/types/plugin.d.ts","./next.config.ts","./node_modules/playwright-core/types/protocol.d.ts","./node_modules/playwright-core/types/structs.d.ts","./node_modules/playwright-core/types/types.d.ts","./node_modules/playwright-core/index.d.ts","./node_modules/playwright/types/test.d.ts","./node_modules/playwright/test.d.ts","./node_modules/@playwright/test/index.d.ts","./playwright.config.ts","./e2e/item-master-data.spec.ts","./node_modules/next-intl/dist/types/routing/types.d.ts","./node_modules/next-intl/dist/types/routing/config.d.ts","./node_modules/next-intl/dist/types/middleware/middleware.d.ts","./node_modules/next-intl/dist/types/middleware/index.d.ts","./node_modules/next-intl/dist/types/middleware.d.ts","./src/i18n/config.ts","./src/lib/api/auth/auth-config.ts","./src/middleware.ts","./src/app/api/auth/check/route.ts","./src/app/api/auth/login/route.ts","./src/app/api/auth/logout/route.ts","./src/app/api/auth/refresh/route.ts","./src/app/api/auth/signup/route.ts","./src/app/api/proxy/[...path]/route.ts","./src/lib/api/php-proxy.ts","./src/app/api/tenants/[tenantid]/item-master-config/route.ts","./src/app/api/tenants/[tenantid]/item-master-config/pages/[pageid]/route.ts","./node_modules/clsx/clsx.d.mts","./node_modules/tailwind-merge/dist/types.d.ts","./src/lib/utils.ts","./src/components/atoms/badgesm.tsx","./src/components/atoms/tabchip.tsx","./src/components/atoms/index.ts","./src/components/ui/table.tsx","./src/components/ui/utils.ts","./src/components/ui/card.tsx","./node_modules/@radix-ui/react-context/dist/index.d.mts","./node_modules/@radix-ui/react-checkbox/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-checkbox/dist/index.d.mts","./node_modules/lucide-react/dist/lucide-react.d.ts","./src/components/ui/checkbox.tsx","./node_modules/@radix-ui/react-slot/dist/index.d.mts","./node_modules/class-variance-authority/dist/types.d.ts","./node_modules/class-variance-authority/dist/index.d.ts","./src/components/ui/button.tsx","./node_modules/@radix-ui/react-dismissable-layer/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-dismissable-layer/dist/index.d.mts","./node_modules/@radix-ui/react-focus-scope/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-focus-scope/dist/index.d.mts","./node_modules/@radix-ui/react-arrow/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-arrow/dist/index.d.mts","./node_modules/@radix-ui/react-popper/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/rect/dist/index.d.mts","./node_modules/@radix-ui/react-popper/dist/index.d.mts","./node_modules/@radix-ui/react-portal/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-portal/dist/index.d.mts","./node_modules/@radix-ui/react-select/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-select/dist/index.d.mts","./src/components/ui/select.tsx","./src/components/common/datatable/types.ts","./src/components/common/datatable/pagination.tsx","./node_modules/@radix-ui/react-tabs/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-roving-focus/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-roving-focus/dist/index.d.mts","./node_modules/@radix-ui/react-tabs/dist/index.d.mts","./src/components/ui/tabs.tsx","./src/components/common/datatable/tabfilter.tsx","./src/components/ui/input.tsx","./src/components/common/datatable/searchfilter.tsx","./src/components/common/datatable/datatable.tsx","./src/components/common/datatable/statcards.tsx","./src/components/common/datatable/index.ts","./src/types/item-master-api.ts","./src/components/items/dynamicitemform/types.ts","./node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-label/dist/index.d.mts","./src/components/ui/label.tsx","./src/components/items/dynamicitemform/fields/textfield.tsx","./src/components/items/dynamicitemform/fields/numberfield.tsx","./src/components/items/dynamicitemform/fields/dropdownfield.tsx","./src/components/items/dynamicitemform/fields/checkboxfield.tsx","./src/components/items/dynamicitemform/fields/datefield.tsx","./src/components/ui/textarea.tsx","./src/components/items/dynamicitemform/fields/textareafield.tsx","./src/components/items/dynamicitemform/fields/dynamicfieldrenderer.tsx","./src/components/items/dynamicitemform/fields/index.ts","./src/lib/api/auth-headers.ts","./src/lib/api/error-handler.ts","./src/lib/api/logger.ts","./src/lib/api/item-master.ts","./src/components/items/dynamicitemform/hooks/useformstructure.ts","./src/components/items/dynamicitemform/hooks/usedynamicformstate.ts","./src/components/items/dynamicitemform/hooks/useconditionaldisplay.ts","./src/components/items/dynamicitemform/hooks/index.ts","./src/components/ui/badge.tsx","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-context/dist/index.d.mts","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-dismissable-layer/dist/index.d.mts","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-focus-scope/dist/index.d.mts","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-arrow/dist/index.d.mts","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/rect/dist/index.d.mts","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-popper/dist/index.d.mts","./node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-portal/dist/index.d.mts","./node_modules/@radix-ui/react-popover/dist/index.d.mts","./src/components/ui/popover.tsx","./node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-dialog/dist/index.d.mts","./node_modules/cmdk/dist/index.d.ts","./node_modules/@radix-ui/react-visually-hidden/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-visually-hidden/dist/index.d.mts","./src/components/ui/visually-hidden.tsx","./src/components/ui/dialog.tsx","./src/components/ui/command.tsx","./src/components/items/dynamicitemform/sections/dynamicbomsection.tsx","./src/components/items/dynamicitemform/sections/index.ts","./src/components/items/dynamicitemform/utils/itemcodegenerator.ts","./src/components/items/itemform/constants.ts","./src/types/item.ts","./node_modules/zod/v4/core/standard-schema.d.cts","./node_modules/zod/v4/core/util.d.cts","./node_modules/zod/v4/core/versions.d.cts","./node_modules/zod/v4/core/schemas.d.cts","./node_modules/zod/v4/core/checks.d.cts","./node_modules/zod/v4/core/errors.d.cts","./node_modules/zod/v4/core/core.d.cts","./node_modules/zod/v4/core/parse.d.cts","./node_modules/zod/v4/core/regexes.d.cts","./node_modules/zod/v4/locales/ar.d.cts","./node_modules/zod/v4/locales/az.d.cts","./node_modules/zod/v4/locales/be.d.cts","./node_modules/zod/v4/locales/bg.d.cts","./node_modules/zod/v4/locales/ca.d.cts","./node_modules/zod/v4/locales/cs.d.cts","./node_modules/zod/v4/locales/da.d.cts","./node_modules/zod/v4/locales/de.d.cts","./node_modules/zod/v4/locales/en.d.cts","./node_modules/zod/v4/locales/eo.d.cts","./node_modules/zod/v4/locales/es.d.cts","./node_modules/zod/v4/locales/fa.d.cts","./node_modules/zod/v4/locales/fi.d.cts","./node_modules/zod/v4/locales/fr.d.cts","./node_modules/zod/v4/locales/fr-ca.d.cts","./node_modules/zod/v4/locales/he.d.cts","./node_modules/zod/v4/locales/hu.d.cts","./node_modules/zod/v4/locales/id.d.cts","./node_modules/zod/v4/locales/is.d.cts","./node_modules/zod/v4/locales/it.d.cts","./node_modules/zod/v4/locales/ja.d.cts","./node_modules/zod/v4/locales/ka.d.cts","./node_modules/zod/v4/locales/kh.d.cts","./node_modules/zod/v4/locales/km.d.cts","./node_modules/zod/v4/locales/ko.d.cts","./node_modules/zod/v4/locales/lt.d.cts","./node_modules/zod/v4/locales/mk.d.cts","./node_modules/zod/v4/locales/ms.d.cts","./node_modules/zod/v4/locales/nl.d.cts","./node_modules/zod/v4/locales/no.d.cts","./node_modules/zod/v4/locales/ota.d.cts","./node_modules/zod/v4/locales/ps.d.cts","./node_modules/zod/v4/locales/pl.d.cts","./node_modules/zod/v4/locales/pt.d.cts","./node_modules/zod/v4/locales/ru.d.cts","./node_modules/zod/v4/locales/sl.d.cts","./node_modules/zod/v4/locales/sv.d.cts","./node_modules/zod/v4/locales/ta.d.cts","./node_modules/zod/v4/locales/th.d.cts","./node_modules/zod/v4/locales/tr.d.cts","./node_modules/zod/v4/locales/ua.d.cts","./node_modules/zod/v4/locales/uk.d.cts","./node_modules/zod/v4/locales/ur.d.cts","./node_modules/zod/v4/locales/vi.d.cts","./node_modules/zod/v4/locales/zh-cn.d.cts","./node_modules/zod/v4/locales/zh-tw.d.cts","./node_modules/zod/v4/locales/yo.d.cts","./node_modules/zod/v4/locales/index.d.cts","./node_modules/zod/v4/core/registries.d.cts","./node_modules/zod/v4/core/doc.d.cts","./node_modules/zod/v4/core/api.d.cts","./node_modules/zod/v4/core/json-schema.d.cts","./node_modules/zod/v4/core/to-json-schema.d.cts","./node_modules/zod/v4/core/index.d.cts","./node_modules/zod/v4/classic/errors.d.cts","./node_modules/zod/v4/classic/parse.d.cts","./node_modules/zod/v4/classic/schemas.d.cts","./node_modules/zod/v4/classic/checks.d.cts","./node_modules/zod/v4/classic/compat.d.cts","./node_modules/zod/v4/classic/iso.d.cts","./node_modules/zod/v4/classic/coerce.d.cts","./node_modules/zod/v4/classic/external.d.cts","./node_modules/zod/index.d.cts","./src/lib/utils/validation.ts","./src/components/items/itemform/types.ts","./node_modules/react-hook-form/dist/constants.d.ts","./node_modules/react-hook-form/dist/utils/createsubject.d.ts","./node_modules/react-hook-form/dist/types/events.d.ts","./node_modules/react-hook-form/dist/types/path/common.d.ts","./node_modules/react-hook-form/dist/types/path/eager.d.ts","./node_modules/react-hook-form/dist/types/path/index.d.ts","./node_modules/react-hook-form/dist/types/fieldarray.d.ts","./node_modules/react-hook-form/dist/types/resolvers.d.ts","./node_modules/react-hook-form/dist/types/form.d.ts","./node_modules/react-hook-form/dist/types/utils.d.ts","./node_modules/react-hook-form/dist/types/fields.d.ts","./node_modules/react-hook-form/dist/types/errors.d.ts","./node_modules/react-hook-form/dist/types/validator.d.ts","./node_modules/react-hook-form/dist/types/controller.d.ts","./node_modules/react-hook-form/dist/types/index.d.ts","./node_modules/react-hook-form/dist/controller.d.ts","./node_modules/react-hook-form/dist/form.d.ts","./node_modules/react-hook-form/dist/logic/appenderrors.d.ts","./node_modules/react-hook-form/dist/logic/createformcontrol.d.ts","./node_modules/react-hook-form/dist/logic/index.d.ts","./node_modules/react-hook-form/dist/usecontroller.d.ts","./node_modules/react-hook-form/dist/usefieldarray.d.ts","./node_modules/react-hook-form/dist/useform.d.ts","./node_modules/react-hook-form/dist/useformcontext.d.ts","./node_modules/react-hook-form/dist/useformstate.d.ts","./node_modules/react-hook-form/dist/usewatch.d.ts","./node_modules/react-hook-form/dist/utils/get.d.ts","./node_modules/react-hook-form/dist/utils/set.d.ts","./node_modules/react-hook-form/dist/utils/index.d.ts","./node_modules/react-hook-form/dist/watch.d.ts","./node_modules/react-hook-form/dist/index.d.ts","./src/components/items/itemform/hooks/useitemformstate.ts","./src/components/items/itemform/hooks/usebommanagement.ts","./src/components/items/itemform/hooks/usebendingdetails.ts","./src/components/items/itemform/context/itemformcontext.tsx","./src/components/items/itemform/context/index.ts","./src/components/items/itemform/forms/materialform.tsx","./src/components/items/itemform/forms/productform.tsx","./src/components/items/itemform/forms/parts/assemblypartform.tsx","./src/components/items/itemform/forms/parts/bendingpartform.tsx","./src/components/items/itemform/forms/parts/purchasedpartform.tsx","./src/components/items/itemform/forms/parts/index.ts","./src/components/items/itemform/forms/partform.tsx","./src/components/items/itemform/forms/index.ts","./src/components/items/itemform/hooks/index.ts","./src/components/items/itemmasterdatamanagement/types.ts","./src/contexts/authcontext.tsx","./src/lib/cache/tenantawarecache.ts","./src/lib/cache/index.ts","./src/lib/api/transformers.ts","./src/contexts/itemmastercontext.tsx","./src/components/items/itemmasterdatamanagement/components/draggablesection.tsx","./src/components/items/itemmasterdatamanagement/components/draggablefield.tsx","./src/components/items/itemmasterdatamanagement/components/index.ts","./node_modules/sonner/dist/index.d.mts","./src/components/items/itemmasterdatamanagement/services/fieldservice.ts","./src/components/items/itemmasterdatamanagement/services/masterfieldservice.ts","./src/components/items/itemmasterdatamanagement/services/sectionservice.ts","./src/components/items/itemmasterdatamanagement/services/pageservice.ts","./src/components/items/itemmasterdatamanagement/services/templateservice.ts","./src/components/items/itemmasterdatamanagement/services/attributeservice.ts","./src/components/items/itemmasterdatamanagement/services/index.ts","./src/components/items/itemmasterdatamanagement/hooks/usepagemanagement.ts","./src/components/items/itemmasterdatamanagement/hooks/usesectionmanagement.ts","./node_modules/@radix-ui/react-switch/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-switch/dist/index.d.mts","./src/components/ui/switch.tsx","./src/components/items/itemmasterdatamanagement/components/conditionaldisplayui.tsx","./src/components/items/itemmasterdatamanagement/hooks/usefieldmanagement.ts","./src/components/items/itemmasterdatamanagement/hooks/usemasterfieldmanagement.ts","./src/components/items/itemmasterdatamanagement/hooks/usetemplatemanagement.ts","./src/components/items/itemmasterdatamanagement/hooks/useattributemanagement.ts","./src/components/items/itemmasterdatamanagement/hooks/usetabmanagement.ts","./src/components/items/itemmasterdatamanagement/hooks/index.ts","./src/components/items/itemmasterdatamanagement/tabs/categorytab/index.tsx","./src/components/items/itemmasterdatamanagement/tabs/masterfieldtab/index.tsx","./src/components/items/bommanagementsection.tsx","./src/components/items/itemmasterdatamanagement/tabs/hierarchytab/index.tsx","./src/components/items/itemmasterdatamanagement/tabs/sectionstab.tsx","./src/components/items/itemmasterdatamanagement/tabs/index.ts","./src/components/items/itemmasterdatamanagement/utils/pathutils.ts","./src/components/molecules/statusbadge.tsx","./src/components/molecules/iconwithbadge.tsx","./node_modules/@radix-ui/react-dropdown-menu/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-menu/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-menu/dist/index.d.mts","./node_modules/@radix-ui/react-dropdown-menu/dist/index.d.mts","./src/components/ui/dropdown-menu.tsx","./src/components/molecules/tableactions.tsx","./src/components/molecules/standarddialog.tsx","./src/components/molecules/index.ts","./src/components/organisms/pageheader.tsx","./src/components/organisms/pagelayout.tsx","./src/components/organisms/statcards.tsx","./src/components/organisms/searchfilter.tsx","./src/components/organisms/datatable.tsx","./src/components/organisms/mobilecard.tsx","./src/components/ui/separator.tsx","./src/components/organisms/listmobilecard.tsx","./src/components/organisms/emptystate.tsx","./src/components/organisms/screenversionhistory.tsx","./src/components/organisms/index.ts","./src/components/templates/listpagetemplate.tsx","./src/components/templates/integratedlisttemplatev2.tsx","./src/components/templates/index.ts","./src/hooks/useauthguard.ts","./src/hooks/usecurrenttime.ts","./src/hooks/useitemlist.ts","./src/hooks/useuserrole.ts","./node_modules/use-intl/dist/types/core/abstractintlmessages.d.ts","./node_modules/use-intl/dist/types/core/translationvalues.d.ts","./node_modules/use-intl/dist/types/core/timezone.d.ts","./node_modules/use-intl/dist/types/core/datetimeformatoptions.d.ts","./node_modules/@formatjs/ecma402-abstract/canonicalizelocalelist.d.ts","./node_modules/@formatjs/ecma402-abstract/canonicalizetimezonename.d.ts","./node_modules/@formatjs/ecma402-abstract/coerceoptionstoobject.d.ts","./node_modules/@formatjs/ecma402-abstract/getnumberoption.d.ts","./node_modules/@formatjs/ecma402-abstract/getoption.d.ts","./node_modules/@formatjs/ecma402-abstract/getoptionsobject.d.ts","./node_modules/@formatjs/ecma402-abstract/getstringorbooleanoption.d.ts","./node_modules/@formatjs/ecma402-abstract/issanctionedsimpleunitidentifier.d.ts","./node_modules/@formatjs/ecma402-abstract/isvalidtimezonename.d.ts","./node_modules/@formatjs/ecma402-abstract/iswellformedcurrencycode.d.ts","./node_modules/@formatjs/ecma402-abstract/iswellformedunitidentifier.d.ts","./node_modules/decimal.js/decimal.d.ts","./node_modules/@formatjs/ecma402-abstract/types/core.d.ts","./node_modules/@formatjs/ecma402-abstract/types/plural-rules.d.ts","./node_modules/@formatjs/ecma402-abstract/types/number.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/applyunsignedroundingmode.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/collapsenumberrange.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/computeexponent.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/computeexponentformagnitude.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/currencydigits.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/format_to_parts.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/formatapproximately.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/formatnumeric.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/formatnumericrange.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/formatnumericrangetoparts.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/formatnumerictoparts.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/formatnumerictostring.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/getunsignedroundingmode.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/initializenumberformat.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/partitionnumberpattern.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/partitionnumberrangepattern.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/setnumberformatdigitoptions.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/setnumberformatunitoptions.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/torawfixed.d.ts","./node_modules/@formatjs/ecma402-abstract/numberformat/torawprecision.d.ts","./node_modules/@formatjs/ecma402-abstract/partitionpattern.d.ts","./node_modules/@formatjs/ecma402-abstract/supportedlocales.d.ts","./node_modules/@formatjs/ecma402-abstract/utils.d.ts","./node_modules/@formatjs/ecma402-abstract/262.d.ts","./node_modules/@formatjs/ecma402-abstract/data.d.ts","./node_modules/@formatjs/ecma402-abstract/types/date-time.d.ts","./node_modules/@formatjs/ecma402-abstract/types/displaynames.d.ts","./node_modules/@formatjs/ecma402-abstract/types/list.d.ts","./node_modules/@formatjs/ecma402-abstract/types/relative-time.d.ts","./node_modules/@formatjs/ecma402-abstract/constants.d.ts","./node_modules/@formatjs/ecma402-abstract/tointlmathematicalvalue.d.ts","./node_modules/@formatjs/ecma402-abstract/index.d.ts","./node_modules/@formatjs/icu-skeleton-parser/date-time.d.ts","./node_modules/@formatjs/icu-skeleton-parser/number.d.ts","./node_modules/@formatjs/icu-skeleton-parser/index.d.ts","./node_modules/@formatjs/icu-messageformat-parser/types.d.ts","./node_modules/@formatjs/icu-messageformat-parser/error.d.ts","./node_modules/@formatjs/icu-messageformat-parser/parser.d.ts","./node_modules/@formatjs/icu-messageformat-parser/manipulator.d.ts","./node_modules/@formatjs/icu-messageformat-parser/index.d.ts","./node_modules/intl-messageformat/src/formatters.d.ts","./node_modules/intl-messageformat/src/core.d.ts","./node_modules/intl-messageformat/src/error.d.ts","./node_modules/intl-messageformat/index.d.ts","./node_modules/use-intl/dist/types/core/numberformatoptions.d.ts","./node_modules/use-intl/dist/types/core/formats.d.ts","./node_modules/use-intl/dist/types/core/appconfig.d.ts","./node_modules/use-intl/dist/types/core/intlerrorcode.d.ts","./node_modules/use-intl/dist/types/core/intlerror.d.ts","./node_modules/use-intl/dist/types/core/types.d.ts","./node_modules/use-intl/dist/types/core/intlconfig.d.ts","./node_modules/@schummar/icu-type-parser/dist/index.d.ts","./node_modules/use-intl/dist/types/core/icuargs.d.ts","./node_modules/use-intl/dist/types/core/icutags.d.ts","./node_modules/use-intl/dist/types/core/messagekeys.d.ts","./node_modules/use-intl/dist/types/core/formatters.d.ts","./node_modules/use-intl/dist/types/core/createtranslator.d.ts","./node_modules/use-intl/dist/types/core/relativetimeformatoptions.d.ts","./node_modules/use-intl/dist/types/core/createformatter.d.ts","./node_modules/use-intl/dist/types/core/initializeconfig.d.ts","./node_modules/use-intl/dist/types/core/haslocale.d.ts","./node_modules/use-intl/dist/types/core/index.d.ts","./node_modules/use-intl/dist/types/core.d.ts","./node_modules/next-intl/dist/types/server/react-server/getrequestconfig.d.ts","./node_modules/next-intl/dist/types/server/react-server/getformatter.d.ts","./node_modules/use-intl/dist/types/react/intlprovider.d.ts","./node_modules/use-intl/dist/types/react/usetranslations.d.ts","./node_modules/use-intl/dist/types/react/uselocale.d.ts","./node_modules/use-intl/dist/types/react/usenow.d.ts","./node_modules/use-intl/dist/types/react/usetimezone.d.ts","./node_modules/use-intl/dist/types/react/usemessages.d.ts","./node_modules/use-intl/dist/types/react/useformatter.d.ts","./node_modules/use-intl/dist/types/react/index.d.ts","./node_modules/use-intl/dist/types/react.d.ts","./node_modules/use-intl/dist/types/index.d.ts","./node_modules/next-intl/dist/types/server/react-server/getnow.d.ts","./node_modules/next-intl/dist/types/server/react-server/gettimezone.d.ts","./node_modules/next-intl/dist/types/server/react-server/gettranslations.d.ts","./node_modules/next-intl/dist/types/server/react-server/getconfig.d.ts","./node_modules/next-intl/dist/types/server/react-server/getmessages.d.ts","./node_modules/next-intl/dist/types/server/react-server/getlocale.d.ts","./node_modules/next-intl/dist/types/server/react-server/requestlocalecache.d.ts","./node_modules/next-intl/dist/types/server/react-server/index.d.ts","./node_modules/next-intl/dist/types/server.react-server.d.ts","./src/i18n/request.ts","./src/lib/api/auth/types.ts","./src/lib/api/client.ts","./src/lib/api/items.ts","./src/types/master-data.ts","./src/lib/api/master-data.ts","./src/lib/auth/token-refresh.ts","./node_modules/zustand/esm/vanilla.d.mts","./node_modules/zustand/esm/react.d.mts","./node_modules/zustand/esm/index.d.mts","./node_modules/zustand/esm/middleware/redux.d.mts","./node_modules/zustand/esm/middleware/devtools.d.mts","./node_modules/zustand/esm/middleware/subscribewithselector.d.mts","./node_modules/zustand/esm/middleware/combine.d.mts","./node_modules/zustand/esm/middleware/persist.d.mts","./node_modules/zustand/esm/middleware.d.mts","./src/store/menustore.ts","./src/lib/utils/menutransform.ts","./src/lib/validations/auth.ts","./src/store/demostore.ts","./src/store/themestore.ts","./src/stores/itemstore.ts","./node_modules/zustand/esm/vanilla/shallow.d.mts","./node_modules/zustand/esm/react/shallow.d.mts","./node_modules/zustand/esm/shallow.d.mts","./src/stores/masterdatastore.ts","./src/utils/formatamount.ts","./src/app/[locale]/error.tsx","./node_modules/next-intl/dist/types/shared/nextintlclientprovider.d.ts","./node_modules/next-intl/dist/types/react-client/index.d.ts","./node_modules/next-intl/dist/types/index.react-client.d.ts","./src/contexts/themecontext.tsx","./src/app/[locale]/layout.tsx","./src/app/[locale]/not-found.tsx","./src/app/[locale]/page.tsx","./src/app/[locale]/(protected)/error.tsx","./src/components/ui/sheet.tsx","./src/components/layout/sidebar.tsx","./src/layouts/dashboardlayout.tsx","./src/contexts/rootprovider.tsx","./src/app/[locale]/(protected)/layout.tsx","./src/components/ui/loading-spinner.tsx","./src/app/[locale]/(protected)/loading.tsx","./src/app/[locale]/(protected)/not-found.tsx","./src/components/common/emptypage.tsx","./src/app/[locale]/(protected)/[...slug]/page.tsx","./src/components/ui/chart-wrapper.tsx","./node_modules/@date-fns/tz/constants/index.d.ts","./node_modules/@date-fns/tz/date/index.d.ts","./node_modules/@date-fns/tz/date/mini.d.ts","./node_modules/@date-fns/tz/tz/index.d.ts","./node_modules/@date-fns/tz/tzoffset/index.d.ts","./node_modules/@date-fns/tz/tzscan/index.d.ts","./node_modules/@date-fns/tz/tzname/index.d.ts","./node_modules/@date-fns/tz/index.d.ts","./node_modules/date-fns/constants.d.ts","./node_modules/date-fns/locale/types.d.ts","./node_modules/date-fns/fp/types.d.ts","./node_modules/date-fns/types.d.ts","./node_modules/date-fns/add.d.ts","./node_modules/date-fns/addbusinessdays.d.ts","./node_modules/date-fns/adddays.d.ts","./node_modules/date-fns/addhours.d.ts","./node_modules/date-fns/addisoweekyears.d.ts","./node_modules/date-fns/addmilliseconds.d.ts","./node_modules/date-fns/addminutes.d.ts","./node_modules/date-fns/addmonths.d.ts","./node_modules/date-fns/addquarters.d.ts","./node_modules/date-fns/addseconds.d.ts","./node_modules/date-fns/addweeks.d.ts","./node_modules/date-fns/addyears.d.ts","./node_modules/date-fns/areintervalsoverlapping.d.ts","./node_modules/date-fns/clamp.d.ts","./node_modules/date-fns/closestindexto.d.ts","./node_modules/date-fns/closestto.d.ts","./node_modules/date-fns/compareasc.d.ts","./node_modules/date-fns/comparedesc.d.ts","./node_modules/date-fns/constructfrom.d.ts","./node_modules/date-fns/constructnow.d.ts","./node_modules/date-fns/daystoweeks.d.ts","./node_modules/date-fns/differenceinbusinessdays.d.ts","./node_modules/date-fns/differenceincalendardays.d.ts","./node_modules/date-fns/differenceincalendarisoweekyears.d.ts","./node_modules/date-fns/differenceincalendarisoweeks.d.ts","./node_modules/date-fns/differenceincalendarmonths.d.ts","./node_modules/date-fns/differenceincalendarquarters.d.ts","./node_modules/date-fns/differenceincalendarweeks.d.ts","./node_modules/date-fns/differenceincalendaryears.d.ts","./node_modules/date-fns/differenceindays.d.ts","./node_modules/date-fns/differenceinhours.d.ts","./node_modules/date-fns/differenceinisoweekyears.d.ts","./node_modules/date-fns/differenceinmilliseconds.d.ts","./node_modules/date-fns/differenceinminutes.d.ts","./node_modules/date-fns/differenceinmonths.d.ts","./node_modules/date-fns/differenceinquarters.d.ts","./node_modules/date-fns/differenceinseconds.d.ts","./node_modules/date-fns/differenceinweeks.d.ts","./node_modules/date-fns/differenceinyears.d.ts","./node_modules/date-fns/eachdayofinterval.d.ts","./node_modules/date-fns/eachhourofinterval.d.ts","./node_modules/date-fns/eachminuteofinterval.d.ts","./node_modules/date-fns/eachmonthofinterval.d.ts","./node_modules/date-fns/eachquarterofinterval.d.ts","./node_modules/date-fns/eachweekofinterval.d.ts","./node_modules/date-fns/eachweekendofinterval.d.ts","./node_modules/date-fns/eachweekendofmonth.d.ts","./node_modules/date-fns/eachweekendofyear.d.ts","./node_modules/date-fns/eachyearofinterval.d.ts","./node_modules/date-fns/endofday.d.ts","./node_modules/date-fns/endofdecade.d.ts","./node_modules/date-fns/endofhour.d.ts","./node_modules/date-fns/endofisoweek.d.ts","./node_modules/date-fns/endofisoweekyear.d.ts","./node_modules/date-fns/endofminute.d.ts","./node_modules/date-fns/endofmonth.d.ts","./node_modules/date-fns/endofquarter.d.ts","./node_modules/date-fns/endofsecond.d.ts","./node_modules/date-fns/endoftoday.d.ts","./node_modules/date-fns/endoftomorrow.d.ts","./node_modules/date-fns/endofweek.d.ts","./node_modules/date-fns/endofyear.d.ts","./node_modules/date-fns/endofyesterday.d.ts","./node_modules/date-fns/_lib/format/formatters.d.ts","./node_modules/date-fns/_lib/format/longformatters.d.ts","./node_modules/date-fns/format.d.ts","./node_modules/date-fns/formatdistance.d.ts","./node_modules/date-fns/formatdistancestrict.d.ts","./node_modules/date-fns/formatdistancetonow.d.ts","./node_modules/date-fns/formatdistancetonowstrict.d.ts","./node_modules/date-fns/formatduration.d.ts","./node_modules/date-fns/formatiso.d.ts","./node_modules/date-fns/formatiso9075.d.ts","./node_modules/date-fns/formatisoduration.d.ts","./node_modules/date-fns/formatrfc3339.d.ts","./node_modules/date-fns/formatrfc7231.d.ts","./node_modules/date-fns/formatrelative.d.ts","./node_modules/date-fns/fromunixtime.d.ts","./node_modules/date-fns/getdate.d.ts","./node_modules/date-fns/getday.d.ts","./node_modules/date-fns/getdayofyear.d.ts","./node_modules/date-fns/getdaysinmonth.d.ts","./node_modules/date-fns/getdaysinyear.d.ts","./node_modules/date-fns/getdecade.d.ts","./node_modules/date-fns/_lib/defaultoptions.d.ts","./node_modules/date-fns/getdefaultoptions.d.ts","./node_modules/date-fns/gethours.d.ts","./node_modules/date-fns/getisoday.d.ts","./node_modules/date-fns/getisoweek.d.ts","./node_modules/date-fns/getisoweekyear.d.ts","./node_modules/date-fns/getisoweeksinyear.d.ts","./node_modules/date-fns/getmilliseconds.d.ts","./node_modules/date-fns/getminutes.d.ts","./node_modules/date-fns/getmonth.d.ts","./node_modules/date-fns/getoverlappingdaysinintervals.d.ts","./node_modules/date-fns/getquarter.d.ts","./node_modules/date-fns/getseconds.d.ts","./node_modules/date-fns/gettime.d.ts","./node_modules/date-fns/getunixtime.d.ts","./node_modules/date-fns/getweek.d.ts","./node_modules/date-fns/getweekofmonth.d.ts","./node_modules/date-fns/getweekyear.d.ts","./node_modules/date-fns/getweeksinmonth.d.ts","./node_modules/date-fns/getyear.d.ts","./node_modules/date-fns/hourstomilliseconds.d.ts","./node_modules/date-fns/hourstominutes.d.ts","./node_modules/date-fns/hourstoseconds.d.ts","./node_modules/date-fns/interval.d.ts","./node_modules/date-fns/intervaltoduration.d.ts","./node_modules/date-fns/intlformat.d.ts","./node_modules/date-fns/intlformatdistance.d.ts","./node_modules/date-fns/isafter.d.ts","./node_modules/date-fns/isbefore.d.ts","./node_modules/date-fns/isdate.d.ts","./node_modules/date-fns/isequal.d.ts","./node_modules/date-fns/isexists.d.ts","./node_modules/date-fns/isfirstdayofmonth.d.ts","./node_modules/date-fns/isfriday.d.ts","./node_modules/date-fns/isfuture.d.ts","./node_modules/date-fns/islastdayofmonth.d.ts","./node_modules/date-fns/isleapyear.d.ts","./node_modules/date-fns/ismatch.d.ts","./node_modules/date-fns/ismonday.d.ts","./node_modules/date-fns/ispast.d.ts","./node_modules/date-fns/issameday.d.ts","./node_modules/date-fns/issamehour.d.ts","./node_modules/date-fns/issameisoweek.d.ts","./node_modules/date-fns/issameisoweekyear.d.ts","./node_modules/date-fns/issameminute.d.ts","./node_modules/date-fns/issamemonth.d.ts","./node_modules/date-fns/issamequarter.d.ts","./node_modules/date-fns/issamesecond.d.ts","./node_modules/date-fns/issameweek.d.ts","./node_modules/date-fns/issameyear.d.ts","./node_modules/date-fns/issaturday.d.ts","./node_modules/date-fns/issunday.d.ts","./node_modules/date-fns/isthishour.d.ts","./node_modules/date-fns/isthisisoweek.d.ts","./node_modules/date-fns/isthisminute.d.ts","./node_modules/date-fns/isthismonth.d.ts","./node_modules/date-fns/isthisquarter.d.ts","./node_modules/date-fns/isthissecond.d.ts","./node_modules/date-fns/isthisweek.d.ts","./node_modules/date-fns/isthisyear.d.ts","./node_modules/date-fns/isthursday.d.ts","./node_modules/date-fns/istoday.d.ts","./node_modules/date-fns/istomorrow.d.ts","./node_modules/date-fns/istuesday.d.ts","./node_modules/date-fns/isvalid.d.ts","./node_modules/date-fns/iswednesday.d.ts","./node_modules/date-fns/isweekend.d.ts","./node_modules/date-fns/iswithininterval.d.ts","./node_modules/date-fns/isyesterday.d.ts","./node_modules/date-fns/lastdayofdecade.d.ts","./node_modules/date-fns/lastdayofisoweek.d.ts","./node_modules/date-fns/lastdayofisoweekyear.d.ts","./node_modules/date-fns/lastdayofmonth.d.ts","./node_modules/date-fns/lastdayofquarter.d.ts","./node_modules/date-fns/lastdayofweek.d.ts","./node_modules/date-fns/lastdayofyear.d.ts","./node_modules/date-fns/_lib/format/lightformatters.d.ts","./node_modules/date-fns/lightformat.d.ts","./node_modules/date-fns/max.d.ts","./node_modules/date-fns/milliseconds.d.ts","./node_modules/date-fns/millisecondstohours.d.ts","./node_modules/date-fns/millisecondstominutes.d.ts","./node_modules/date-fns/millisecondstoseconds.d.ts","./node_modules/date-fns/min.d.ts","./node_modules/date-fns/minutestohours.d.ts","./node_modules/date-fns/minutestomilliseconds.d.ts","./node_modules/date-fns/minutestoseconds.d.ts","./node_modules/date-fns/monthstoquarters.d.ts","./node_modules/date-fns/monthstoyears.d.ts","./node_modules/date-fns/nextday.d.ts","./node_modules/date-fns/nextfriday.d.ts","./node_modules/date-fns/nextmonday.d.ts","./node_modules/date-fns/nextsaturday.d.ts","./node_modules/date-fns/nextsunday.d.ts","./node_modules/date-fns/nextthursday.d.ts","./node_modules/date-fns/nexttuesday.d.ts","./node_modules/date-fns/nextwednesday.d.ts","./node_modules/date-fns/parse/_lib/types.d.ts","./node_modules/date-fns/parse/_lib/setter.d.ts","./node_modules/date-fns/parse/_lib/parser.d.ts","./node_modules/date-fns/parse/_lib/parsers.d.ts","./node_modules/date-fns/parse.d.ts","./node_modules/date-fns/parseiso.d.ts","./node_modules/date-fns/parsejson.d.ts","./node_modules/date-fns/previousday.d.ts","./node_modules/date-fns/previousfriday.d.ts","./node_modules/date-fns/previousmonday.d.ts","./node_modules/date-fns/previoussaturday.d.ts","./node_modules/date-fns/previoussunday.d.ts","./node_modules/date-fns/previousthursday.d.ts","./node_modules/date-fns/previoustuesday.d.ts","./node_modules/date-fns/previouswednesday.d.ts","./node_modules/date-fns/quarterstomonths.d.ts","./node_modules/date-fns/quarterstoyears.d.ts","./node_modules/date-fns/roundtonearesthours.d.ts","./node_modules/date-fns/roundtonearestminutes.d.ts","./node_modules/date-fns/secondstohours.d.ts","./node_modules/date-fns/secondstomilliseconds.d.ts","./node_modules/date-fns/secondstominutes.d.ts","./node_modules/date-fns/set.d.ts","./node_modules/date-fns/setdate.d.ts","./node_modules/date-fns/setday.d.ts","./node_modules/date-fns/setdayofyear.d.ts","./node_modules/date-fns/setdefaultoptions.d.ts","./node_modules/date-fns/sethours.d.ts","./node_modules/date-fns/setisoday.d.ts","./node_modules/date-fns/setisoweek.d.ts","./node_modules/date-fns/setisoweekyear.d.ts","./node_modules/date-fns/setmilliseconds.d.ts","./node_modules/date-fns/setminutes.d.ts","./node_modules/date-fns/setmonth.d.ts","./node_modules/date-fns/setquarter.d.ts","./node_modules/date-fns/setseconds.d.ts","./node_modules/date-fns/setweek.d.ts","./node_modules/date-fns/setweekyear.d.ts","./node_modules/date-fns/setyear.d.ts","./node_modules/date-fns/startofday.d.ts","./node_modules/date-fns/startofdecade.d.ts","./node_modules/date-fns/startofhour.d.ts","./node_modules/date-fns/startofisoweek.d.ts","./node_modules/date-fns/startofisoweekyear.d.ts","./node_modules/date-fns/startofminute.d.ts","./node_modules/date-fns/startofmonth.d.ts","./node_modules/date-fns/startofquarter.d.ts","./node_modules/date-fns/startofsecond.d.ts","./node_modules/date-fns/startoftoday.d.ts","./node_modules/date-fns/startoftomorrow.d.ts","./node_modules/date-fns/startofweek.d.ts","./node_modules/date-fns/startofweekyear.d.ts","./node_modules/date-fns/startofyear.d.ts","./node_modules/date-fns/startofyesterday.d.ts","./node_modules/date-fns/sub.d.ts","./node_modules/date-fns/subbusinessdays.d.ts","./node_modules/date-fns/subdays.d.ts","./node_modules/date-fns/subhours.d.ts","./node_modules/date-fns/subisoweekyears.d.ts","./node_modules/date-fns/submilliseconds.d.ts","./node_modules/date-fns/subminutes.d.ts","./node_modules/date-fns/submonths.d.ts","./node_modules/date-fns/subquarters.d.ts","./node_modules/date-fns/subseconds.d.ts","./node_modules/date-fns/subweeks.d.ts","./node_modules/date-fns/subyears.d.ts","./node_modules/date-fns/todate.d.ts","./node_modules/date-fns/transpose.d.ts","./node_modules/date-fns/weekstodays.d.ts","./node_modules/date-fns/yearstodays.d.ts","./node_modules/date-fns/yearstomonths.d.ts","./node_modules/date-fns/yearstoquarters.d.ts","./node_modules/date-fns/index.d.ts","./node_modules/date-fns/locale/af.d.ts","./node_modules/date-fns/locale/ar.d.ts","./node_modules/date-fns/locale/ar-dz.d.ts","./node_modules/date-fns/locale/ar-eg.d.ts","./node_modules/date-fns/locale/ar-ma.d.ts","./node_modules/date-fns/locale/ar-sa.d.ts","./node_modules/date-fns/locale/ar-tn.d.ts","./node_modules/date-fns/locale/az.d.ts","./node_modules/date-fns/locale/be.d.ts","./node_modules/date-fns/locale/be-tarask.d.ts","./node_modules/date-fns/locale/bg.d.ts","./node_modules/date-fns/locale/bn.d.ts","./node_modules/date-fns/locale/bs.d.ts","./node_modules/date-fns/locale/ca.d.ts","./node_modules/date-fns/locale/ckb.d.ts","./node_modules/date-fns/locale/cs.d.ts","./node_modules/date-fns/locale/cy.d.ts","./node_modules/date-fns/locale/da.d.ts","./node_modules/date-fns/locale/de.d.ts","./node_modules/date-fns/locale/de-at.d.ts","./node_modules/date-fns/locale/el.d.ts","./node_modules/date-fns/locale/en-au.d.ts","./node_modules/date-fns/locale/en-ca.d.ts","./node_modules/date-fns/locale/en-gb.d.ts","./node_modules/date-fns/locale/en-ie.d.ts","./node_modules/date-fns/locale/en-in.d.ts","./node_modules/date-fns/locale/en-nz.d.ts","./node_modules/date-fns/locale/en-us.d.ts","./node_modules/date-fns/locale/en-za.d.ts","./node_modules/date-fns/locale/eo.d.ts","./node_modules/date-fns/locale/es.d.ts","./node_modules/date-fns/locale/et.d.ts","./node_modules/date-fns/locale/eu.d.ts","./node_modules/date-fns/locale/fa-ir.d.ts","./node_modules/date-fns/locale/fi.d.ts","./node_modules/date-fns/locale/fr.d.ts","./node_modules/date-fns/locale/fr-ca.d.ts","./node_modules/date-fns/locale/fr-ch.d.ts","./node_modules/date-fns/locale/fy.d.ts","./node_modules/date-fns/locale/gd.d.ts","./node_modules/date-fns/locale/gl.d.ts","./node_modules/date-fns/locale/gu.d.ts","./node_modules/date-fns/locale/he.d.ts","./node_modules/date-fns/locale/hi.d.ts","./node_modules/date-fns/locale/hr.d.ts","./node_modules/date-fns/locale/ht.d.ts","./node_modules/date-fns/locale/hu.d.ts","./node_modules/date-fns/locale/hy.d.ts","./node_modules/date-fns/locale/id.d.ts","./node_modules/date-fns/locale/is.d.ts","./node_modules/date-fns/locale/it.d.ts","./node_modules/date-fns/locale/it-ch.d.ts","./node_modules/date-fns/locale/ja.d.ts","./node_modules/date-fns/locale/ja-hira.d.ts","./node_modules/date-fns/locale/ka.d.ts","./node_modules/date-fns/locale/kk.d.ts","./node_modules/date-fns/locale/km.d.ts","./node_modules/date-fns/locale/kn.d.ts","./node_modules/date-fns/locale/ko.d.ts","./node_modules/date-fns/locale/lb.d.ts","./node_modules/date-fns/locale/lt.d.ts","./node_modules/date-fns/locale/lv.d.ts","./node_modules/date-fns/locale/mk.d.ts","./node_modules/date-fns/locale/mn.d.ts","./node_modules/date-fns/locale/ms.d.ts","./node_modules/date-fns/locale/mt.d.ts","./node_modules/date-fns/locale/nb.d.ts","./node_modules/date-fns/locale/nl.d.ts","./node_modules/date-fns/locale/nl-be.d.ts","./node_modules/date-fns/locale/nn.d.ts","./node_modules/date-fns/locale/oc.d.ts","./node_modules/date-fns/locale/pl.d.ts","./node_modules/date-fns/locale/pt.d.ts","./node_modules/date-fns/locale/pt-br.d.ts","./node_modules/date-fns/locale/ro.d.ts","./node_modules/date-fns/locale/ru.d.ts","./node_modules/date-fns/locale/se.d.ts","./node_modules/date-fns/locale/sk.d.ts","./node_modules/date-fns/locale/sl.d.ts","./node_modules/date-fns/locale/sq.d.ts","./node_modules/date-fns/locale/sr.d.ts","./node_modules/date-fns/locale/sr-latn.d.ts","./node_modules/date-fns/locale/sv.d.ts","./node_modules/date-fns/locale/ta.d.ts","./node_modules/date-fns/locale/te.d.ts","./node_modules/date-fns/locale/th.d.ts","./node_modules/date-fns/locale/tr.d.ts","./node_modules/date-fns/locale/ug.d.ts","./node_modules/date-fns/locale/uk.d.ts","./node_modules/date-fns/locale/uz.d.ts","./node_modules/date-fns/locale/uz-cyrl.d.ts","./node_modules/date-fns/locale/vi.d.ts","./node_modules/date-fns/locale/zh-cn.d.ts","./node_modules/date-fns/locale/zh-hk.d.ts","./node_modules/date-fns/locale/zh-tw.d.ts","./node_modules/date-fns/locale.d.ts","./node_modules/react-day-picker/dist/esm/components/button.d.ts","./node_modules/react-day-picker/dist/esm/components/captionlabel.d.ts","./node_modules/react-day-picker/dist/esm/components/chevron.d.ts","./node_modules/react-day-picker/dist/esm/components/monthcaption.d.ts","./node_modules/react-day-picker/dist/esm/components/week.d.ts","./node_modules/react-day-picker/dist/esm/labels/labeldaybutton.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelgrid.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelgridcell.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelmonthdropdown.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelnav.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelnext.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelprevious.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelweekday.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelweeknumber.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelweeknumberheader.d.ts","./node_modules/react-day-picker/dist/esm/labels/labelyeardropdown.d.ts","./node_modules/react-day-picker/dist/esm/labels/index.d.ts","./node_modules/react-day-picker/dist/esm/ui.d.ts","./node_modules/react-day-picker/dist/esm/classes/calendarweek.d.ts","./node_modules/react-day-picker/dist/esm/classes/calendarmonth.d.ts","./node_modules/react-day-picker/dist/esm/types/props.d.ts","./node_modules/react-day-picker/dist/esm/types/selection.d.ts","./node_modules/react-day-picker/dist/esm/usedaypicker.d.ts","./node_modules/react-day-picker/dist/esm/types/deprecated.d.ts","./node_modules/react-day-picker/dist/esm/types/index.d.ts","./node_modules/react-day-picker/dist/esm/components/day.d.ts","./node_modules/react-day-picker/dist/esm/components/daybutton.d.ts","./node_modules/react-day-picker/dist/esm/components/dropdown.d.ts","./node_modules/react-day-picker/dist/esm/components/dropdownnav.d.ts","./node_modules/react-day-picker/dist/esm/components/footer.d.ts","./node_modules/react-day-picker/dist/esm/components/month.d.ts","./node_modules/react-day-picker/dist/esm/components/monthgrid.d.ts","./node_modules/react-day-picker/dist/esm/components/months.d.ts","./node_modules/react-day-picker/dist/esm/components/monthsdropdown.d.ts","./node_modules/react-day-picker/dist/esm/components/nav.d.ts","./node_modules/react-day-picker/dist/esm/components/nextmonthbutton.d.ts","./node_modules/react-day-picker/dist/esm/components/option.d.ts","./node_modules/react-day-picker/dist/esm/components/previousmonthbutton.d.ts","./node_modules/react-day-picker/dist/esm/components/root.d.ts","./node_modules/react-day-picker/dist/esm/components/select.d.ts","./node_modules/react-day-picker/dist/esm/components/weekday.d.ts","./node_modules/react-day-picker/dist/esm/components/weekdays.d.ts","./node_modules/react-day-picker/dist/esm/components/weeknumber.d.ts","./node_modules/react-day-picker/dist/esm/components/weeknumberheader.d.ts","./node_modules/react-day-picker/dist/esm/components/weeks.d.ts","./node_modules/react-day-picker/dist/esm/components/yearsdropdown.d.ts","./node_modules/react-day-picker/dist/esm/components/custom-components.d.ts","./node_modules/react-day-picker/dist/esm/formatters/formatcaption.d.ts","./node_modules/react-day-picker/dist/esm/formatters/formatday.d.ts","./node_modules/react-day-picker/dist/esm/formatters/formatmonthdropdown.d.ts","./node_modules/react-day-picker/dist/esm/formatters/formatweekdayname.d.ts","./node_modules/react-day-picker/dist/esm/formatters/formatweeknumber.d.ts","./node_modules/react-day-picker/dist/esm/formatters/formatweeknumberheader.d.ts","./node_modules/react-day-picker/dist/esm/formatters/formatyeardropdown.d.ts","./node_modules/react-day-picker/dist/esm/formatters/index.d.ts","./node_modules/react-day-picker/dist/esm/types/shared.d.ts","./node_modules/react-day-picker/dist/esm/classes/datelib.d.ts","./node_modules/react-day-picker/dist/esm/classes/calendarday.d.ts","./node_modules/react-day-picker/dist/esm/classes/index.d.ts","./node_modules/react-day-picker/dist/esm/daypicker.d.ts","./node_modules/react-day-picker/dist/esm/helpers/getdefaultclassnames.d.ts","./node_modules/react-day-picker/dist/esm/helpers/index.d.ts","./node_modules/react-day-picker/dist/esm/utils/addtorange.d.ts","./node_modules/react-day-picker/dist/esm/utils/datematchmodifiers.d.ts","./node_modules/react-day-picker/dist/esm/utils/rangecontainsdayofweek.d.ts","./node_modules/react-day-picker/dist/esm/utils/rangecontainsmodifiers.d.ts","./node_modules/react-day-picker/dist/esm/utils/rangeincludesdate.d.ts","./node_modules/react-day-picker/dist/esm/utils/rangeoverlaps.d.ts","./node_modules/react-day-picker/dist/esm/utils/typeguards.d.ts","./node_modules/react-day-picker/dist/esm/utils/index.d.ts","./node_modules/react-day-picker/dist/esm/index.d.ts","./src/components/ui/calendar.tsx","./node_modules/recharts/types/container/surface.d.ts","./node_modules/recharts/types/container/layer.d.ts","./node_modules/recharts/types/shape/dot.d.ts","./node_modules/@types/d3-path/index.d.ts","./node_modules/@types/d3-shape/index.d.ts","./node_modules/victory-vendor/d3-shape.d.ts","./node_modules/recharts/types/synchronisation/types.d.ts","./node_modules/recharts/types/chart/types.d.ts","./node_modules/recharts/types/component/defaulttooltipcontent.d.ts","./node_modules/recharts/types/component/text.d.ts","./node_modules/recharts/types/zindex/zindexlayer.d.ts","./node_modules/recharts/types/component/label.d.ts","./node_modules/recharts/types/cartesian/cartesianaxis.d.ts","./node_modules/redux/dist/redux.d.ts","./node_modules/immer/dist/immer.d.ts","./node_modules/reselect/dist/reselect.d.ts","./node_modules/redux-thunk/dist/redux-thunk.d.ts","./node_modules/@reduxjs/toolkit/dist/uncheckedindexed.ts","./node_modules/@reduxjs/toolkit/dist/index.d.mts","./node_modules/recharts/types/state/brushslice.d.ts","./node_modules/recharts/types/context/brushupdatecontext.d.ts","./node_modules/recharts/types/state/chartdataslice.d.ts","./node_modules/recharts/types/animation/easing.d.ts","./node_modules/recharts/types/shape/rectangle.d.ts","./node_modules/recharts/types/component/labellist.d.ts","./node_modules/recharts/types/util/barutils.d.ts","./node_modules/recharts/types/state/types/linesettings.d.ts","./node_modules/recharts/types/state/types/scattersettings.d.ts","./node_modules/recharts/types/shape/curve.d.ts","./node_modules/recharts/types/util/stacks/stacktypes.d.ts","./node_modules/recharts/types/state/selectors/areaselectors.d.ts","./node_modules/recharts/types/cartesian/area.d.ts","./node_modules/recharts/types/state/types/areasettings.d.ts","./node_modules/recharts/types/state/types/radialbarsettings.d.ts","./node_modules/recharts/types/util/svgpropertiesnoevents.d.ts","./node_modules/recharts/types/util/useuniqueid.d.ts","./node_modules/recharts/types/state/types/piesettings.d.ts","./node_modules/recharts/types/state/types/radarsettings.d.ts","./node_modules/recharts/types/state/graphicalitemsslice.d.ts","./node_modules/recharts/types/state/types/stackedgraphicalitem.d.ts","./node_modules/recharts/types/state/types/barsettings.d.ts","./node_modules/recharts/types/cartesian/bar.d.ts","./node_modules/recharts/types/cartesian/line.d.ts","./node_modules/recharts/types/shape/symbols.d.ts","./node_modules/recharts/types/cartesian/scatter.d.ts","./node_modules/recharts/types/cartesian/errorbar.d.ts","./node_modules/recharts/types/state/errorbarslice.d.ts","./node_modules/recharts/types/state/legendslice.d.ts","./node_modules/recharts/types/state/optionsslice.d.ts","./node_modules/recharts/types/state/polaraxisslice.d.ts","./node_modules/recharts/types/state/polaroptionsslice.d.ts","./node_modules/recharts/types/util/ifoverflow.d.ts","./node_modules/recharts/types/util/resolvedefaultprops.d.ts","./node_modules/recharts/types/cartesian/referenceline.d.ts","./node_modules/recharts/types/state/referenceelementsslice.d.ts","./node_modules/recharts/types/state/rootpropsslice.d.ts","./node_modules/recharts/types/state/store.d.ts","./node_modules/recharts/types/cartesian/getticks.d.ts","./node_modules/recharts/types/cartesian/cartesiangrid.d.ts","./node_modules/recharts/types/state/selectors/combiners/combinedisplayedstackeddata.d.ts","./node_modules/recharts/types/state/selectors/selecttooltipaxistype.d.ts","./node_modules/recharts/types/state/selectors/axisselectors.d.ts","./node_modules/recharts/types/state/cartesianaxisslice.d.ts","./node_modules/recharts/types/state/tooltipslice.d.ts","./node_modules/recharts/types/util/chartutils.d.ts","./node_modules/recharts/types/component/dots.d.ts","./node_modules/recharts/types/util/types.d.ts","./node_modules/recharts/types/component/defaultlegendcontent.d.ts","./node_modules/recharts/types/util/payload/getuniqpayload.d.ts","./node_modules/recharts/types/util/useelementoffset.d.ts","./node_modules/recharts/types/component/legend.d.ts","./node_modules/recharts/types/component/cursor.d.ts","./node_modules/recharts/types/component/tooltip.d.ts","./node_modules/recharts/types/component/responsivecontainer.d.ts","./node_modules/recharts/types/component/cell.d.ts","./node_modules/recharts/types/component/customized.d.ts","./node_modules/recharts/types/shape/sector.d.ts","./node_modules/recharts/types/shape/polygon.d.ts","./node_modules/recharts/types/shape/cross.d.ts","./node_modules/recharts/types/polar/polargrid.d.ts","./node_modules/recharts/types/polar/defaultpolarradiusaxisprops.d.ts","./node_modules/recharts/types/polar/polarradiusaxis.d.ts","./node_modules/recharts/types/polar/defaultpolarangleaxisprops.d.ts","./node_modules/recharts/types/polar/polarangleaxis.d.ts","./node_modules/recharts/types/polar/pie.d.ts","./node_modules/recharts/types/polar/radar.d.ts","./node_modules/recharts/types/polar/radialbar.d.ts","./node_modules/recharts/types/cartesian/brush.d.ts","./node_modules/recharts/types/cartesian/referencedot.d.ts","./node_modules/recharts/types/cartesian/referencearea.d.ts","./node_modules/recharts/types/cartesian/xaxis.d.ts","./node_modules/recharts/types/cartesian/yaxis.d.ts","./node_modules/recharts/types/cartesian/zaxis.d.ts","./node_modules/recharts/types/chart/linechart.d.ts","./node_modules/recharts/types/chart/barchart.d.ts","./node_modules/recharts/types/chart/piechart.d.ts","./node_modules/recharts/types/chart/treemap.d.ts","./node_modules/recharts/types/chart/sankey.d.ts","./node_modules/recharts/types/chart/radarchart.d.ts","./node_modules/recharts/types/chart/scatterchart.d.ts","./node_modules/recharts/types/chart/areachart.d.ts","./node_modules/recharts/types/chart/radialbarchart.d.ts","./node_modules/recharts/types/chart/composedchart.d.ts","./node_modules/recharts/types/chart/sunburstchart.d.ts","./node_modules/recharts/types/shape/trapezoid.d.ts","./node_modules/recharts/types/cartesian/funnel.d.ts","./node_modules/recharts/types/chart/funnelchart.d.ts","./node_modules/recharts/types/util/global.d.ts","./node_modules/recharts/types/zindex/defaultzindexes.d.ts","./node_modules/decimal.js-light/decimal.d.ts","./node_modules/recharts/types/util/scale/getnicetickvalues.d.ts","./node_modules/recharts/types/types.d.ts","./node_modules/recharts/types/hooks.d.ts","./node_modules/recharts/types/context/chartlayoutcontext.d.ts","./node_modules/recharts/types/index.d.ts","./src/components/business/maindashboard.tsx","./src/components/business/dashboard.tsx","./src/app/[locale]/(protected)/dashboard/page.tsx","./node_modules/@radix-ui/react-alert-dialog/dist/index.d.mts","./src/components/ui/alert-dialog.tsx","./src/components/items/itemlistclient.tsx","./src/app/[locale]/(protected)/items/page.tsx","./src/components/items/itemdetailclient.tsx","./src/app/[locale]/(protected)/items/[id]/page.tsx","./node_modules/zod/v3/helpers/typealiases.d.cts","./node_modules/zod/v3/helpers/util.d.cts","./node_modules/zod/v3/zoderror.d.cts","./node_modules/zod/v3/locales/en.d.cts","./node_modules/zod/v3/errors.d.cts","./node_modules/zod/v3/helpers/parseutil.d.cts","./node_modules/zod/v3/helpers/enumutil.d.cts","./node_modules/zod/v3/helpers/errorutil.d.cts","./node_modules/zod/v3/helpers/partialutil.d.cts","./node_modules/zod/v3/standard-schema.d.cts","./node_modules/zod/v3/types.d.cts","./node_modules/zod/v3/external.d.cts","./node_modules/zod/v3/index.d.cts","./node_modules/@hookform/resolvers/zod/dist/zod.d.ts","./node_modules/@hookform/resolvers/zod/dist/index.d.ts","./src/components/ui/alert.tsx","./src/components/items/itemtypeselect.tsx","./node_modules/@radix-ui/react-slider/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-slider/dist/index.d.mts","./src/components/ui/slider.tsx","./src/components/items/drawingcanvas.tsx","./src/components/items/itemform/validationalert.tsx","./src/components/items/itemform/formheader.tsx","./src/components/items/itemform/bendingdiagramsection.tsx","./src/components/items/itemform/bomsection.tsx","./src/components/items/itemform/index.tsx","./src/app/[locale]/(protected)/items/[id]/edit/page.tsx","./src/components/items/dynamicitemform/index.tsx","./src/app/[locale]/(protected)/items/create/page.tsx","./src/components/items/itemmasterdatamanagement/dialogs/fielddialog.tsx","./node_modules/vaul/dist/index.d.mts","./src/components/ui/drawer.tsx","./src/components/items/itemmasterdatamanagement/dialogs/fielddrawer.tsx","./src/components/items/itemmasterdatamanagement/dialogs/tabmanagementdialogs.tsx","./src/components/items/itemmasterdatamanagement/dialogs/optiondialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/columnmanagedialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/patheditdialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/pagedialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/sectiondialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/masterfielddialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/templatefielddialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/loadtemplatedialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/columndialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/sectiontemplatedialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/importsectiondialog.tsx","./src/components/items/itemmasterdatamanagement/dialogs/importfielddialog.tsx","./src/components/common/servererrorpage.tsx","./src/components/items/itemmasterdatamanagement.tsx","./src/app/[locale]/(protected)/master-data/item-master-data-management/page.tsx","./src/app/[locale]/(protected)/production/screen-production/page.tsx","./src/app/[locale]/(protected)/production/screen-production/[id]/page.tsx","./src/app/[locale]/(protected)/production/screen-production/[id]/edit/page.tsx","./src/app/[locale]/(protected)/production/screen-production/create/page.tsx","./src/app/[locale]/(protected)/sales/client-management-sales-admin/page.tsx","./src/app/[locale]/(protected)/sales/quote-management/page.tsx","./src/components/languageselect.tsx","./src/components/themeselect.tsx","./src/components/auth/loginpage.tsx","./src/app/[locale]/login/page.tsx","./src/components/auth/signuppage.tsx","./src/app/[locale]/signup/page.tsx","./src/components/items/fileupload.tsx","./src/components/ui/error-message.tsx","./node_modules/@radix-ui/react-progress/node_modules/@radix-ui/react-context/dist/index.d.mts","./node_modules/@radix-ui/react-progress/dist/index.d.mts","./src/components/ui/progress.tsx","./node_modules/@radix-ui/react-tooltip/node_modules/@radix-ui/react-primitive/dist/index.d.mts","./node_modules/@radix-ui/react-tooltip/dist/index.d.mts","./src/components/ui/tooltip.tsx","./src/contexts/_unused/accountingcontext.tsx","./src/contexts/_unused/developermodecontext.tsx","./src/contexts/_unused/facilitiescontext.tsx","./src/contexts/_unused/hrcontext.tsx","./src/contexts/_unused/inventorycontext.tsx","./src/contexts/_unused/pricingcontext.tsx","./src/contexts/_unused/productioncontext.tsx","./src/contexts/_unused/salescontext.tsx","./src/contexts/_unused/shippingcontext.tsx","./.next/types/cache-life.d.ts","./.next/types/server.d.ts","./.next/types/validator.ts","./.next/types/app/[locale]/layout.ts","./.next/types/app/[locale]/(protected)/layout.ts","./.next/types/app/[locale]/(protected)/[...slug]/page.ts","./.next/types/app/[locale]/(protected)/items/page.ts","./.next/types/app/[locale]/(protected)/items/create/page.ts","./.next/types/app/[locale]/(protected)/master-data/item-master-data-management/page.ts","./.next/types/app/[locale]/(protected)/production/screen-production/page.ts","./.next/types/app/[locale]/(protected)/sales/client-management-sales-admin/page.ts","./.next/types/app/[locale]/(protected)/sales/quote-management/page.ts","./.next/types/app/api/auth/check/route.ts","./.next/types/app/api/proxy/[...path]/route.ts","./node_modules/@types/d3-array/index.d.ts","./node_modules/@types/d3-color/index.d.ts","./node_modules/@types/d3-ease/index.d.ts","./node_modules/@types/d3-interpolate/index.d.ts","./node_modules/@types/d3-time/index.d.ts","./node_modules/@types/d3-scale/index.d.ts","./node_modules/@types/d3-timer/index.d.ts","./node_modules/@types/estree/index.d.ts","./node_modules/@types/json-schema/index.d.ts","./node_modules/@types/json5/index.d.ts","./node_modules/@types/use-sync-external-store/index.d.ts"],"fileIdsList":[[100,146,337,951],[100,146,337,1539],[100,146,337,1508],[100,146,337,946],[100,146,337,1559],[100,146,337,1560],[100,146,337,1564],[100,146,337,1565],[100,146,337,938],[100,146,491,520],[100,146,491,525],[100,146,444,445,446,447],[100,146],[100,145,146,275,277,278,280,328,432,482,483,484,487,488,490],[83,100,146,491,494,520,521,522,523,524,525,527,528,938,940,946,951,1504,1508,1510,1537,1539,1559,1560,1561,1562,1563,1564,1565,1569,1571],[100,146,509],[83,100,146,495,496],[100,146,495,501],[100,146,953],[100,146,954],[100,146,953,954,955,956,957,958,959],[100,146,818],[100,146,807,808,809,810,811,812,813,814,815,816,817,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852],[100,146,818,821],[100,146,821],[100,146,819],[100,146,818,819,820],[100,146,819,821],[100,146,819,820],[100,146,857],[100,146,857,859,860],[100,146,857,858],[100,146,853,856],[100,146,854,855],[100,146,853],[100,146,1524],[100,146,682,724,1523],[100,146,508],[86,100,146,538,608],[86,100,146,539],[86,100,146],[86,100,146,262,538,539],[86,100,146,538,539,548,550,557],[86,100,146,538,539,779],[86,100,146,576],[86,100,146,538,539,548,550,555,557,565],[86,100,146,597,598,599,600,603,604],[86,100,146,598],[86,100,146,597,598,601,602],[86,100,146,538,539,552,554],[86,100,146,576,1574],[86,100,146,538,539],[86,100,146,538,539,548,550,555,557],[86,90,100,146,195,196,197,198,199,439,487],[86,100,146,538,539,565],[86,100,146,538,539,548,555,557],[100,146,1400,1401,1402,1403,1404],[100,146,1604],[100,146,1607],[100,146,1390],[100,143,146],[100,145,146],[146],[100,146,151,179],[100,146,147,152,157,165,176,187],[100,146,147,148,157,165],[95,96,97,100,146],[100,146,149,188],[100,146,150,151,158,166],[100,146,151,176,184],[100,146,152,154,157,165],[100,145,146,153],[100,146,154,155],[100,146,156,157],[100,145,146,157],[100,146,157,158,159,176,187],[100,146,157,158,159,172,176,179],[100,146,154,157,160,165,176,187],[100,146,157,158,160,161,165,176,184,187],[100,146,160,162,176,184,187],[98,99,100,101,102,103,104,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],[100,146,157,163],[100,146,164,187,192],[100,146,154,157,165,176],[100,146,166],[100,146,167],[100,145,146,168],[100,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],[100,146,170],[100,146,171],[100,146,157,172,173],[100,146,172,174,188,190],[100,146,157,176,177,179],[100,146,178,179],[100,146,176,177],[100,146,179],[100,146,180],[100,143,146,176,181],[100,146,157,182,183],[100,146,182,183],[100,146,151,165,176,184],[100,146,185],[100,146,165,186],[100,146,160,171,187],[100,146,151,188],[100,146,176,189],[100,146,164,190],[100,146,191],[100,141,146],[100,141,146,157,159,168,176,179,187,190,192],[100,146,176,193],[86,90,100,146,195,196,197,199,439,487,543],[86,90,100,146,195,196,197,198,354,439,487,543],[86,90,100,146,195,196,198,199,439,487,543],[86,100,146,199,354,355],[86,100,146,199,354],[86,90,100,146,196,197,198,199,439,487,543],[86,90,100,146,195,197,198,199,439,487,543],[84,85,100,146],[100,146,529,544],[100,146,529],[86,100,146,608],[100,146,964],[100,146,962,964],[100,146,962],[100,146,964,1028,1029],[100,146,964,1031],[100,146,964,1032],[100,146,1049],[100,146,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217],[100,146,964,1125],[100,146,962,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313],[100,146,964,1029,1149],[100,146,962,1146,1147],[100,146,1148],[100,146,964,1146],[100,146,961,962,963],[100,146,862,863,864],[100,146,861,862],[100,146,853,861],[100,146,935],[100,146,515],[100,146,514],[100,146,491,512,513],[100,146,500],[100,146,495,498],[100,146,499],[100,146,896,934],[100,146,491,512],[100,146,904],[100,146,884],[100,146,896],[100,146,896,900],[100,146,885,886,897,898,899,901,902,903],[86,100,146,262,895,896],[92,100,146],[100,146,442],[100,146,449],[100,146,203,217,218,219,221,436],[100,146,203,242,244,246,247,250,436,438],[100,146,203,207,209,210,211,212,213,425,436,438],[100,146,436],[100,146,218,320,406,415,432],[100,146,203],[100,146,200,432],[100,146,254],[100,146,253,436,438],[100,146,160,302,320,349,493],[100,146,160,313,329,415,431],[100,146,160,367],[100,146,419],[100,146,418,419,420],[100,146,418],[94,100,146,160,200,203,207,210,214,215,216,218,222,230,231,360,385,416,436,439],[100,146,203,220,238,242,243,248,249,436,493],[100,146,220,493],[100,146,231,238,300,436,493],[100,146,493],[100,146,203,220,221,493],[100,146,245,493],[100,146,214,417,424],[100,146,171,262,432],[100,146,262,432],[86,100,146,262],[86,100,146,321],[100,146,317,365,432,475,476],[100,146,412,469,470,471,472,474],[100,146,411],[100,146,411,412],[100,146,211,361,362,363],[100,146,361,364,365],[100,146,473],[100,146,361,365],[86,100,146,204,463],[86,100,146,187],[86,100,146,220,290],[86,100,146,220],[100,146,288,292],[86,100,146,289,441],[86,90,100,146,160,194,195,196,197,198,199,439,485,486,543],[100,146,160],[100,146,160,207,269,361,371,386,406,421,422,436,437,493],[100,146,230,423],[100,146,439],[100,146,202],[86,100,146,302,316,328,338,340,431],[100,146,171,302,316,337,338,339,431,492],[100,146,331,332,333,334,335,336],[100,146,333],[100,146,337],[100,146,260,261,262,264],[86,100,146,255,256,257,263],[100,146,260,263],[100,146,258],[100,146,259],[86,100,146,262,289,441],[86,100,146,262,440,441],[86,100,146,262,441],[100,146,386,428],[100,146,428],[100,146,160,437,441],[100,146,325],[100,145,146,324],[100,146,232,270,308,310,312,313,314,315,358,361,431,434,437],[100,146,232,346,361,365],[100,146,313,431],[86,100,146,313,322,323,325,326,327,328,329,330,341,342,343,344,345,347,348,431,432,493],[100,146,307],[100,146,160,171,232,233,269,284,314,358,359,360,365,386,406,427,436,437,438,439,493],[100,146,431],[100,145,146,218,311,314,360,427,429,430,437],[100,146,313],[100,145,146,269,274,303,304,305,306,307,308,309,310,312,431,432],[100,146,160,274,275,303,437,438],[100,146,218,360,361,386,427,431,437],[100,146,160,436,438],[100,146,160,176,434,437,438],[100,146,160,171,187,200,207,220,232,233,235,270,271,276,281,284,310,314,361,371,373,376,378,381,382,383,384,385,406,426,427,432,434,436,437,438],[100,146,160,176],[100,146,203,204,205,207,212,215,220,238,426,434,435,439,441,493],[100,146,160,176,187,250,252,254,255,256,257,264,493],[100,146,171,187,200,242,252,280,281,282,283,310,361,376,385,386,392,395,396,406,427,432,434],[100,146,214,215,230,360,385,427,436],[100,146,160,187,204,207,310,390,434,436],[100,146,301],[100,146,160,393,394,403],[100,146,434,436],[100,146,308,311],[100,146,310,314,426,441],[100,146,160,171,236,242,283,376,386,392,395,398,434],[100,146,160,214,230,242,399],[100,146,203,235,401,426,436],[100,146,160,187,436],[100,146,160,220,234,235,236,247,265,400,402,426,436],[94,100,146,232,314,405,439,441],[100,146,160,171,187,207,214,222,230,233,270,276,280,281,282,283,284,310,361,373,386,387,389,391,406,426,427,432,433,434,441],[100,146,160,176,214,392,397,403,434],[100,146,225,226,227,228,229],[100,146,271,377],[100,146,379],[100,146,377],[100,146,379,380],[100,146,160,207,210,211,269,437],[100,146,160,171,202,204,232,270,284,314,369,370,406,434,438,439,441],[100,146,160,171,187,206,211,310,370,433,437],[100,146,303],[100,146,304],[100,146,305],[100,146,432],[100,146,251,267],[100,146,160,207,251,270],[100,146,266,267],[100,146,268],[100,146,251,252],[100,146,251,285],[100,146,251],[100,146,271,375,433],[100,146,374],[100,146,252,432,433],[100,146,372,433],[100,146,252,432],[100,146,358],[100,146,207,212,270,299,302,308,310,314,316,319,350,353,357,361,405,426,434,437],[100,146,293,296,297,298,317,318,365],[86,100,146,197,199,262,351,352],[86,100,146,197,199,262,351,352,356],[100,146,414],[100,146,218,275,313,314,325,329,361,405,407,408,409,410,412,413,416,426,431,436],[100,146,365],[100,146,369],[100,146,160,270,286,366,368,371,405,434,439,441],[100,146,293,294,295,296,297,298,317,318,365,440],[94,100,146,160,171,187,233,251,252,284,310,314,403,404,406,426,427,436,437,439],[100,146,275,277,280,427],[100,146,160,271,436],[100,146,274,313],[100,146,273],[100,146,275,276],[100,146,272,274,436],[100,146,160,206,275,277,278,279,436,437],[86,100,146,361,362,364],[100,146,237],[86,100,146,204],[86,100,146,432],[86,94,100,146,284,314,439,441],[100,146,204,463,464],[86,100,146,292],[86,100,146,171,187,202,249,287,289,291,441],[100,146,220,432,437],[100,146,388,432],[100,146,361],[86,100,146,158,160,171,202,238,244,292,439,440],[86,100,146,195,196,197,198,199,439,487,543],[86,87,88,89,90,100,146],[100,146,151],[100,146,239,240,241],[100,146,239],[86,90,100,146,160,162,171,194,195,196,197,198,199,200,202,233,337,398,436,438,441,487,543],[100,146,451],[100,146,453],[100,146,455],[100,146,457],[100,146,459,460,461],[100,146,465],[91,93,100,146,443,448,450,452,454,456,458,462,466,468,478,479,481,491,492,493,494],[100,146,467],[100,146,477],[100,146,289],[100,146,480],[100,145,146,275,277,278,280,328,432,482,483,484,487,488,489,490],[100,146,194],[100,146,505],[100,146,147,158,176,503,504],[100,146,507],[100,146,506],[100,146,1371],[100,146,1333],[100,146,1372],[100,146,1218,1246,1314,1370],[100,146,1333,1334,1371,1372],[100,146,1315,1316,1317,1318,1319,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360],[86,100,146,1339,1373],[86,100,146,1339],[86,100,146,1334],[86,100,146,1373],[86,100,146,1342],[100,146,1362,1363,1364,1365,1366,1367,1368],[100,146,1339],[100,146,1375],[100,146,960,1331,1332,1337,1339,1361,1369,1373,1374,1376,1384],[100,146,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330],[100,146,1339,1371],[100,146,1318,1319,1331,1332,1335,1337,1370],[100,146,1335,1336,1338,1370],[86,100,146,1332,1370,1371],[100,146,1335,1370],[86,100,146,1331,1332,1361,1369],[86,100,146,1334,1335,1336,1370,1372],[100,146,1377,1378,1379,1380,1381,1382,1383],[86,100,146,708],[100,146,708,709,710,713,714,715,716,717,718,719,722,723],[100,146,708],[100,146,711,712],[86,100,146,706,708],[100,146,703,704,706],[100,146,699,702,704,706],[100,146,703,706],[86,100,146,694,695,696,699,700,701,703,704,705,706],[100,146,696,699,700,701,702,703,704,705,706,707],[100,146,703],[100,146,697,703,704],[100,146,697,698],[100,146,702,704,705],[100,146,702],[100,146,694,699,704,705],[100,146,720,721],[86,100,146,1397,1408,1415,1417,1419,1448,1453],[86,100,146,1392,1397,1409,1410,1411,1412,1427,1448,1451,1453],[86,100,146,1407,1453],[86,100,146,1396,1397,1398,1449,1451,1453],[86,100,146,1397,1444,1449,1451,1453],[86,100,146,1397,1428,1429,1431,1453],[86,100,146,1411,1450,1453,1491],[100,146,1449,1453],[86,100,146,1397,1411,1415,1448,1449,1453],[86,100,146,1397,1398,1410,1438],[86,100,146,1389,1397,1398,1438],[86,100,146,1397,1398,1438,1439,1453],[86,100,146,1395,1397,1411,1414,1415,1430,1448,1449,1450,1453],[86,100,146,1449,1453],[86,100,146,1449,1451,1453],[86,100,146,1448,1451,1453],[86,100,146,1453],[86,100,146,1410,1450,1453],[86,100,146,1450,1453],[86,100,146,1393],[86,100,146,1397,1450,1453],[86,100,146,1389,1397,1453],[86,100,146,1396,1397,1453],[86,100,146,1397,1398,1453,1501],[86,100,146,1454,1455,1456],[86,100,146,1394,1395,1449,1450,1453,1455,1458],[100,146,1443,1453],[100,146,1448,1449,1453,1498],[100,146,1387,1388,1389,1393,1395,1396,1397,1398,1399,1410,1411,1415,1418,1428,1429,1430,1431,1432,1438,1440,1445,1453,1454,1457,1459,1460,1461,1462,1463,1464,1465,1466,1468,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1497,1498,1499,1500],[86,100,146,1397,1411,1421,1423,1450,1453],[86,100,146,1396,1397,1439,1451,1453,1469],[86,100,146,1397,1449],[86,100,146,1397,1439,1453,1467],[86,100,146,1397,1451,1453],[86,100,146,1392,1397,1408,1411,1448,1449,1451,1453,1463],[86,100,146,1392,1453],[86,100,146,1409,1453],[100,146,1400,1405,1453],[100,146,1399,1400,1405,1448,1451,1453],[100,146,1400,1405,1407],[100,146,1400,1405,1425,1432,1453],[100,146,1400,1405,1408,1413,1414,1419,1420,1423,1424,1427,1449,1453],[100,146,1400,1405,1453,1454,1457],[100,146,1400,1405,1450,1453],[100,146,1400,1405,1449],[100,146,1400,1405],[100,146,1400,1401,1405,1438,1440,1449],[100,146,1393,1400,1405,1418,1453],[100,146,1392,1416,1425,1443,1449,1453],[100,146,1400,1402,1406,1408,1416,1425,1426,1433,1434,1435,1436,1437,1441,1442,1443,1445,1446,1447,1449,1450,1451,1453,1501],[100,146,1408,1416,1426,1449],[100,146,1443],[100,146,1400,1405,1406,1408,1425,1433,1434,1435,1436,1437,1441,1442,1449,1450,1453,1501],[100,146,1394,1395,1400,1405,1449,1453],[100,146,1408,1418,1425,1426,1453],[100,146,1412,1425,1426],[100,146,1408,1425,1453],[86,100,146,1395,1421,1422,1425,1453],[100,146,1425],[100,146,1425,1426],[100,146,1395,1408,1425,1453],[100,146,1425,1451,1453],[100,146,1450,1453],[86,100,146,1410,1428,1453],[100,146,1392,1395,1416,1434,1448,1450,1453],[100,146,1453,1496],[100,146,1392,1425,1426,1451],[86,100,146,1389,1393,1394,1418,1421,1448,1451,1452],[100,146,1400],[100,146,176,194],[100,113,117,146,187],[100,113,146,176,187],[100,108,146],[100,110,113,146,184,187],[100,146,165,184],[100,108,146,194],[100,110,113,146,165,187],[100,105,106,109,112,146,157,176,187],[100,113,120,146],[100,105,111,146],[100,113,134,135,146],[100,109,113,146,179,187,194],[100,134,146,194],[100,107,108,146,194],[100,113,146],[100,107,108,109,110,111,112,113,114,115,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,135,136,137,138,139,140,146],[100,113,128,146],[100,113,120,121,146],[100,111,113,121,122,146],[100,112,146],[100,105,108,113,146],[100,113,117,121,122,146],[100,117,146],[100,111,113,116,146,187],[100,105,110,113,120,146],[100,146,176],[100,108,113,134,146,192,194],[100,146,883],[86,100,146,805,806,866,867,868,870,877,879],[86,100,146,804,867,871,872,874,875,876,877],[100,146,805],[100,146,806,866],[100,146,865],[100,146,868],[100,146,873],[100,146,803,804,805,806,866,867,868,869,870,872,874,875,876,877,878,879,880,881,882],[100,146,870,872],[100,146,805,867,868,870,871],[100,146,869],[100,146,884,895],[100,146,894],[100,146,887,888,889,890,891,892,893],[86,100,146,262,872],[100,146,880],[100,146,868,876,878],[100,146,1391],[100,146,690],[100,146,1513,1514],[100,146,1511,1512,1513,1515,1516,1521],[100,146,1512,1513],[100,146,1521],[100,146,1522],[100,146,1513],[100,146,1511,1512,1513,1516,1517,1518,1519,1520],[100,146,1511,1512,1523],[100,146,682],[100,146,682,685],[100,146,676,682,683,684,685,686,687,688,689],[100,146,682,683],[100,146,682,684],[100,146,621,623,624,625,626],[100,146,621,623,625,626],[100,146,621,623,625],[100,146,620,621,623,624,626],[100,146,621,622,623,624,625,626,627,628,676,677,678,679,680,681],[100,146,623,626],[100,146,620,621,622,624,625,626],[100,146,623,677,680],[100,146,623,624,625,626],[100,146,625],[100,146,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675],[100,146,913,914,916,917,918,920],[100,146,916,917,918,919,920],[100,146,913,916,917,918,920],[100,146,928,929],[86,100,146,478,950],[100,146,1503],[86,100,146,468,537,541,546],[86,100,146,478,619,692,1536],[86,100,146,478,619,1509],[86,100,146,575,1538],[100,146,1507],[100,146,799,944,945],[100,146,947],[86,100,146,495,1558],[100,146,468,537,541,546],[100,146,692,1536],[86,100,146,619,1507],[86,100,146,535,541,542,546,569,578,596,613,748,792,797,1506],[86,100,146,532,535,541,542,546,596,748,783,791,792,797,932,1506],[100,146,478,495,517,905,936,937],[100,146,1568],[86,100,146,478],[100,146,1570],[100,146,1590],[100,146,526,1590],[86,100,146,531],[100,146,532,533],[86,100,146,478,541,546,569,578,923,936,1566,1567],[86,100,146,478,541,546,560,569,578,924,936,1566,1567],[86,100,146,947,1502],[86,100,146,537,541,542,546,560,596,800,952,1386,1501],[86,100,146,531,535,537,541,542,546,561,562,568,570],[100,146,561,562,568,570,571,572],[100,146,541,546,560,561],[100,146,541,560,561,569],[100,146,537,561],[100,146,561,567],[86,100,146,541],[100,146,478,537,541,546],[86,100,146,537,541,546,560,569,578,596,613,744,748],[86,100,146,541,546,578,613,1530],[100,146,542,575,578],[100,146,569,575,578],[100,146,560,575,578],[100,146,575,579,580,581,582,583,585],[100,146,579,580,581,582,583,585,586],[100,146,575,578,584],[100,146,592,593,594],[86,100,146,575],[86,100,146,574,575],[86,100,146,575,591],[86,100,146,478,531,537,541,546,569,574,575,578,587,595,616,617,619,947,1526,1527,1531,1534],[86,100,146,535,537,541,546,569,575,578,596,606,614],[100,146,615],[100,146,574],[86,100,146,541,546,569,578],[100,146,478,535,537,541,546,578,596,619],[100,146,537,541,546,569,578,619,692,724],[86,100,146,535,537,541,546,569,578,596,606,614,619,693],[100,146,728],[86,100,146,619,692,724,725,726,727],[100,146,541,546,619],[100,146,730,731,736],[100,146,560,569,578,619,692,724],[100,146,560,578,692,724,735],[100,146,542,560,569,578,692,724],[100,146,560,569,578,618,692,724],[100,146,732,733,734],[100,146,542,560,569,578,618,692,724],[100,146,541,542,546,560,569,578,584,692,724],[100,146,725,726,727],[86,100,146,619,692,724],[86,100,146,619],[86,100,146,478,537,569,578,618,619,692,693,724,737,738,1525,1526,1527,1531,1532,1533,1534,1535],[100,146,619,692],[100,146,618,692,724,1526],[86,100,146,478,535,541,542,546,596,619,797,801,1506],[86,100,146,537,541,546,567,589,591,596,743,744,748,767,773,785,786,947,1540,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557],[100,146,541,546,569,578,596,744,748,760],[86,100,146,541,546,596,744],[86,100,146,541,546,569,744],[100,146,745,746],[86,100,146,546,569,578,613,748],[100,146,541,546,560,569,578,596,613,739,748,760],[86,100,146,541,546,560,569,578,584,596,613,744,748,755,760,761],[100,146,541,546,560,569,578,584,596,744,748,760,1542],[86,100,146,541,546,569,574,578,596,613,744],[100,146,541,546,596,613,744],[86,100,146,546,560,569,578,584,596,613,755,760],[86,100,146,546,560,569,578,613,760],[86,100,146,546,560,569,578,613],[86,100,146,541,546,569,578,584,613,744],[86,100,146,546,560,569,578,584,613],[100,146,541,546,569,578,596,613,1506],[86,100,146,541,546,560,569,578,584,596,613,744,760],[100,146,756,757,762,763,764,765,766],[86,100,146,739,744,748,755],[86,100,146,744,748,755,761],[86,100,146,744,748,755],[86,100,146,589,744,748,755],[86,100,146,541,744,748],[100,146,739],[100,146,744],[100,146,749,750,751,752,753,754],[100,146,744,749],[100,146,537,541,546,569,596,748],[86,100,146,537,541,546,569,744,747,748,770],[100,146,768,769,771,772],[100,146,537,541,546,596,744],[86,100,146,537,541,546,567,596,744,770],[100,146,560,578,619],[100,146,478,541,560,936],[86,100,146,541,922],[100,146,531,541,596],[100,146,775,776,782,783],[100,146,531,546,613],[100,146,532,541,596],[100,146,541,546,781],[86,100,146,531,535,537,541,546,596,775,776,782],[100,146,541,546],[100,146,785,786,787,788,789,790,792,793,794],[86,100,146,542,791],[86,100,146,537,541,546,596],[100,146,537,541,596],[86,100,146,541,569],[100,146,537,541],[100,146,796,797],[86,100,146,533,535,537,541,542,546,567,613,785,786,787,788,794],[86,100,146,541,785,786,787,788,789,790,793],[100,146,541,560,937],[86,100,146,536,546,1505],[86,100,146,536,545],[86,100,146,536,543,545],[86,100,146,531,543,545],[86,100,146,536,541,546,1385],[86,100,146,536],[86,100,146,536,540,541],[86,100,146,536,541,609,613],[86,100,146,536,541,608,612],[86,100,146,536,1541],[86,100,146,536,541,780],[86,100,146,541,1526],[86,100,146,531,577],[86,100,146,536,605],[86,100,146,536,1575],[86,100,146,531,541,559],[86,100,146,536,541,608],[86,100,146,531,1529],[86,100,146,536,759],[86,100,146,531,566],[86,100,146,536,1578],[100,146,529,530],[86,100,146,611],[86,100,146,574,589,591,740,742,743],[86,100,146,740,744],[86,100,146,574,591,619],[100,146,517,905],[86,100,146,478,541,546,569,781,922,923,937,942,943],[100,146,518,907],[100,146,574,588,589,590],[100,146,619,1589],[100,146,910,1589],[100,146,574,744],[100,146,741],[100,146,541,922],[100,146,619,691],[100,146,691],[100,146,516,517,518,1590],[100,146,915,921],[100,146,541,915,921],[100,146,619,915,921],[100,146,910,911,915,921,930],[100,146,619]],"fileInfos":[{"version":"c430d44666289dae81f30fa7b2edebf186ecc91a2d4c71266ea6ae76388792e1","affectsGlobalScope":true,"impliedFormat":1},{"version":"45b7ab580deca34ae9729e97c13cfd999df04416a79116c3bfb483804f85ded4","impliedFormat":1},{"version":"3facaf05f0c5fc569c5649dd359892c98a85557e3e0c847964caeb67076f4d75","impliedFormat":1},{"version":"e44bb8bbac7f10ecc786703fe0a6a4b952189f908707980ba8f3c8975a760962","impliedFormat":1},{"version":"5e1c4c362065a6b95ff952c0eab010f04dcd2c3494e813b493ecfd4fcb9fc0d8","impliedFormat":1},{"version":"68d73b4a11549f9c0b7d352d10e91e5dca8faa3322bfb77b661839c42b1ddec7","impliedFormat":1},{"version":"5efce4fc3c29ea84e8928f97adec086e3dc876365e0982cc8479a07954a3efd4","impliedFormat":1},{"version":"feecb1be483ed332fad555aff858affd90a48ab19ba7272ee084704eb7167569","impliedFormat":1},{"version":"ee7bad0c15b58988daa84371e0b89d313b762ab83cb5b31b8a2d1162e8eb41c2","impliedFormat":1},{"version":"27bdc30a0e32783366a5abeda841bc22757c1797de8681bbe81fbc735eeb1c10","impliedFormat":1},{"version":"8fd575e12870e9944c7e1d62e1f5a73fcf23dd8d3a321f2a2c74c20d022283fe","impliedFormat":1},{"version":"2ab096661c711e4a81cc464fa1e6feb929a54f5340b46b0a07ac6bbf857471f0","impliedFormat":1},{"version":"080941d9f9ff9307f7e27a83bcd888b7c8270716c39af943532438932ec1d0b9","affectsGlobalScope":true,"impliedFormat":1},{"version":"2e80ee7a49e8ac312cc11b77f1475804bee36b3b2bc896bead8b6e1266befb43","affectsGlobalScope":true,"impliedFormat":1},{"version":"c57796738e7f83dbc4b8e65132f11a377649c00dd3eee333f672b8f0a6bea671","affectsGlobalScope":true,"impliedFormat":1},{"version":"dc2df20b1bcdc8c2d34af4926e2c3ab15ffe1160a63e58b7e09833f616efff44","affectsGlobalScope":true,"impliedFormat":1},{"version":"515d0b7b9bea2e31ea4ec968e9edd2c39d3eebf4a2d5cbd04e88639819ae3b71","affectsGlobalScope":true,"impliedFormat":1},{"version":"0559b1f683ac7505ae451f9a96ce4c3c92bdc71411651ca6ddb0e88baaaad6a3","affectsGlobalScope":true,"impliedFormat":1},{"version":"0dc1e7ceda9b8b9b455c3a2d67b0412feab00bd2f66656cd8850e8831b08b537","affectsGlobalScope":true,"impliedFormat":1},{"version":"ce691fb9e5c64efb9547083e4a34091bcbe5bdb41027e310ebba8f7d96a98671","affectsGlobalScope":true,"impliedFormat":1},{"version":"8d697a2a929a5fcb38b7a65594020fcef05ec1630804a33748829c5ff53640d0","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ff2a353abf8a80ee399af572debb8faab2d33ad38c4b4474cff7f26e7653b8d","affectsGlobalScope":true,"impliedFormat":1},{"version":"fb0f136d372979348d59b3f5020b4cdb81b5504192b1cacff5d1fbba29378aa1","affectsGlobalScope":true,"impliedFormat":1},{"version":"d15bea3d62cbbdb9797079416b8ac375ae99162a7fba5de2c6c505446486ac0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"68d18b664c9d32a7336a70235958b8997ebc1c3b8505f4f1ae2b7e7753b87618","affectsGlobalScope":true,"impliedFormat":1},{"version":"eb3d66c8327153d8fa7dd03f9c58d351107fe824c79e9b56b462935176cdf12a","affectsGlobalScope":true,"impliedFormat":1},{"version":"38f0219c9e23c915ef9790ab1d680440d95419ad264816fa15009a8851e79119","affectsGlobalScope":true,"impliedFormat":1},{"version":"69ab18c3b76cd9b1be3d188eaf8bba06112ebbe2f47f6c322b5105a6fbc45a2e","affectsGlobalScope":true,"impliedFormat":1},{"version":"a680117f487a4d2f30ea46f1b4b7f58bef1480456e18ba53ee85c2746eeca012","affectsGlobalScope":true,"impliedFormat":1},{"version":"2f11ff796926e0832f9ae148008138ad583bd181899ab7dd768a2666700b1893","affectsGlobalScope":true,"impliedFormat":1},{"version":"4de680d5bb41c17f7f68e0419412ca23c98d5749dcaaea1896172f06435891fc","affectsGlobalScope":true,"impliedFormat":1},{"version":"954296b30da6d508a104a3a0b5d96b76495c709785c1d11610908e63481ee667","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac9538681b19688c8eae65811b329d3744af679e0bdfa5d842d0e32524c73e1c","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a969edff4bd52585473d24995c5ef223f6652d6ef46193309b3921d65dd4376","affectsGlobalScope":true,"impliedFormat":1},{"version":"9e9fbd7030c440b33d021da145d3232984c8bb7916f277e8ffd3dc2e3eae2bdb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811ec78f7fefcabbda4bfa93b3eb67d9ae166ef95f9bff989d964061cbf81a0c","affectsGlobalScope":true,"impliedFormat":1},{"version":"717937616a17072082152a2ef351cb51f98802fb4b2fdabd32399843875974ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"d7e7d9b7b50e5f22c915b525acc5a49a7a6584cf8f62d0569e557c5cfc4b2ac2","affectsGlobalScope":true,"impliedFormat":1},{"version":"71c37f4c9543f31dfced6c7840e068c5a5aacb7b89111a4364b1d5276b852557","affectsGlobalScope":true,"impliedFormat":1},{"version":"576711e016cf4f1804676043e6a0a5414252560eb57de9faceee34d79798c850","affectsGlobalScope":true,"impliedFormat":1},{"version":"89c1b1281ba7b8a96efc676b11b264de7a8374c5ea1e6617f11880a13fc56dc6","affectsGlobalScope":true,"impliedFormat":1},{"version":"74f7fa2d027d5b33eb0471c8e82a6c87216223181ec31247c357a3e8e2fddc5b","affectsGlobalScope":true,"impliedFormat":1},{"version":"d6d7ae4d1f1f3772e2a3cde568ed08991a8ae34a080ff1151af28b7f798e22ca","affectsGlobalScope":true,"impliedFormat":1},{"version":"063600664504610fe3e99b717a1223f8b1900087fab0b4cad1496a114744f8df","affectsGlobalScope":true,"impliedFormat":1},{"version":"934019d7e3c81950f9a8426d093458b65d5aff2c7c1511233c0fd5b941e608ab","affectsGlobalScope":true,"impliedFormat":1},{"version":"52ada8e0b6e0482b728070b7639ee42e83a9b1c22d205992756fe020fd9f4a47","affectsGlobalScope":true,"impliedFormat":1},{"version":"3bdefe1bfd4d6dee0e26f928f93ccc128f1b64d5d501ff4a8cf3c6371200e5e6","affectsGlobalScope":true,"impliedFormat":1},{"version":"59fb2c069260b4ba00b5643b907ef5d5341b167e7d1dbf58dfd895658bda2867","affectsGlobalScope":true,"impliedFormat":1},{"version":"639e512c0dfc3fad96a84caad71b8834d66329a1f28dc95e3946c9b58176c73a","affectsGlobalScope":true,"impliedFormat":1},{"version":"368af93f74c9c932edd84c58883e736c9e3d53cec1fe24c0b0ff451f529ceab1","affectsGlobalScope":true,"impliedFormat":1},{"version":"af3dd424cf267428f30ccfc376f47a2c0114546b55c44d8c0f1d57d841e28d74","affectsGlobalScope":true,"impliedFormat":1},{"version":"995c005ab91a498455ea8dfb63aa9f83fa2ea793c3d8aa344be4a1678d06d399","affectsGlobalScope":true,"impliedFormat":1},{"version":"959d36cddf5e7d572a65045b876f2956c973a586da58e5d26cde519184fd9b8a","affectsGlobalScope":true,"impliedFormat":1},{"version":"965f36eae237dd74e6cca203a43e9ca801ce38824ead814728a2807b1910117d","affectsGlobalScope":true,"impliedFormat":1},{"version":"3925a6c820dcb1a06506c90b1577db1fdbf7705d65b62b99dce4be75c637e26b","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a3d63ef2b853447ec4f749d3f368ce642264246e02911fcb1590d8c161b8005","affectsGlobalScope":true,"impliedFormat":1},{"version":"8cdf8847677ac7d20486e54dd3fcf09eda95812ac8ace44b4418da1bbbab6eb8","affectsGlobalScope":true,"impliedFormat":1},{"version":"8444af78980e3b20b49324f4a16ba35024fef3ee069a0eb67616ea6ca821c47a","affectsGlobalScope":true,"impliedFormat":1},{"version":"3287d9d085fbd618c3971944b65b4be57859f5415f495b33a6adc994edd2f004","affectsGlobalScope":true,"impliedFormat":1},{"version":"b4b67b1a91182421f5df999988c690f14d813b9850b40acd06ed44691f6727ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"df83c2a6c73228b625b0beb6669c7ee2a09c914637e2d35170723ad49c0f5cd4","affectsGlobalScope":true,"impliedFormat":1},{"version":"436aaf437562f276ec2ddbee2f2cdedac7664c1e4c1d2c36839ddd582eeb3d0a","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e3c06ea092138bf9fa5e874a1fdbc9d54805d074bee1de31b99a11e2fec239d","affectsGlobalScope":true,"impliedFormat":1},{"version":"87dc0f382502f5bbce5129bdc0aea21e19a3abbc19259e0b43ae038a9fc4e326","affectsGlobalScope":true,"impliedFormat":1},{"version":"b1cb28af0c891c8c96b2d6b7be76bd394fddcfdb4709a20ba05a7c1605eea0f9","affectsGlobalScope":true,"impliedFormat":1},{"version":"2fef54945a13095fdb9b84f705f2b5994597640c46afeb2ce78352fab4cb3279","affectsGlobalScope":true,"impliedFormat":1},{"version":"ac77cb3e8c6d3565793eb90a8373ee8033146315a3dbead3bde8db5eaf5e5ec6","affectsGlobalScope":true,"impliedFormat":1},{"version":"56e4ed5aab5f5920980066a9409bfaf53e6d21d3f8d020c17e4de584d29600ad","affectsGlobalScope":true,"impliedFormat":1},{"version":"4ece9f17b3866cc077099c73f4983bddbcb1dc7ddb943227f1ec070f529dedd1","affectsGlobalScope":true,"impliedFormat":1},{"version":"0a6282c8827e4b9a95f4bf4f5c205673ada31b982f50572d27103df8ceb8013c","affectsGlobalScope":true,"impliedFormat":1},{"version":"1c9319a09485199c1f7b0498f2988d6d2249793ef67edda49d1e584746be9032","affectsGlobalScope":true,"impliedFormat":1},{"version":"e3a2a0cee0f03ffdde24d89660eba2685bfbdeae955a6c67e8c4c9fd28928eeb","affectsGlobalScope":true,"impliedFormat":1},{"version":"811c71eee4aa0ac5f7adf713323a5c41b0cf6c4e17367a34fbce379e12bbf0a4","affectsGlobalScope":true,"impliedFormat":1},{"version":"51ad4c928303041605b4d7ae32e0c1ee387d43a24cd6f1ebf4a2699e1076d4fa","affectsGlobalScope":true,"impliedFormat":1},{"version":"60037901da1a425516449b9a20073aa03386cce92f7a1fd902d7602be3a7c2e9","affectsGlobalScope":true,"impliedFormat":1},{"version":"d4b1d2c51d058fc21ec2629fff7a76249dec2e36e12960ea056e3ef89174080f","affectsGlobalScope":true,"impliedFormat":1},{"version":"22adec94ef7047a6c9d1af3cb96be87a335908bf9ef386ae9fd50eeb37f44c47","affectsGlobalScope":true,"impliedFormat":1},{"version":"196cb558a13d4533a5163286f30b0509ce0210e4b316c56c38d4c0fd2fb38405","affectsGlobalScope":true,"impliedFormat":1},{"version":"73f78680d4c08509933daf80947902f6ff41b6230f94dd002ae372620adb0f60","affectsGlobalScope":true,"impliedFormat":1},{"version":"c5239f5c01bcfa9cd32f37c496cf19c61d69d37e48be9de612b541aac915805b","affectsGlobalScope":true,"impliedFormat":1},{"version":"8e7f8264d0fb4c5339605a15daadb037bf238c10b654bb3eee14208f860a32ea","affectsGlobalScope":true,"impliedFormat":1},{"version":"782dec38049b92d4e85c1585fbea5474a219c6984a35b004963b00beb1aab538","affectsGlobalScope":true,"impliedFormat":1},{"version":"7a67e6e86ca6a79605117ce72063779506d541d5c66d1b6c40ae70a8c28cce75","affectsGlobalScope":true},{"version":"170d4db14678c68178ee8a3d5a990d5afb759ecb6ec44dbd885c50f6da6204f6","affectsGlobalScope":true,"impliedFormat":1},{"version":"8a8eb4ebffd85e589a1cc7c178e291626c359543403d58c9cd22b81fab5b1fb9","impliedFormat":1},{"version":"0ff1b165090b491f5e1407ae680b9a0bc3806dc56827ec85f93c57390491e732","impliedFormat":1},{"version":"acd8fd5090ac73902278889c38336ff3f48af6ba03aa665eb34a75e7ba1dccc4","impliedFormat":1},{"version":"d6258883868fb2680d2ca96bc8b1352cab69874581493e6d52680c5ffecdb6cc","impliedFormat":1},{"version":"1b61d259de5350f8b1e5db06290d31eaebebc6baafd5f79d314b5af9256d7153","impliedFormat":1},{"version":"f258e3960f324a956fc76a3d3d9e964fff2244ff5859dcc6ce5951e5413ca826","impliedFormat":1},{"version":"643f7232d07bf75e15bd8f658f664d6183a0efaca5eb84b48201c7671a266979","impliedFormat":1},{"version":"0f6666b58e9276ac3a38fdc80993d19208442d6027ab885580d93aec76b4ef00","impliedFormat":1},{"version":"05fd364b8ef02fb1e174fbac8b825bdb1e5a36a016997c8e421f5fab0a6da0a0","impliedFormat":1},{"version":"631eff75b0e35d1b1b31081d55209abc43e16b49426546ab5a9b40bdd40b1f60","impliedFormat":1},{"version":"70521b6ab0dcba37539e5303104f29b721bfb2940b2776da4cc818c07e1fefc1","affectsGlobalScope":true,"impliedFormat":1},{"version":"ab41ef1f2cdafb8df48be20cd969d875602483859dc194e9c97c8a576892c052","affectsGlobalScope":true,"impliedFormat":1},{"version":"d153a11543fd884b596587ccd97aebbeed950b26933ee000f94009f1ab142848","affectsGlobalScope":true,"impliedFormat":1},{"version":"21d819c173c0cf7cc3ce57c3276e77fd9a8a01d35a06ad87158781515c9a438a","impliedFormat":1},{"version":"98cffbf06d6bab333473c70a893770dbe990783904002c4f1a960447b4b53dca","affectsGlobalScope":true,"impliedFormat":1},{"version":"ba481bca06f37d3f2c137ce343c7d5937029b2468f8e26111f3c9d9963d6568d","affectsGlobalScope":true,"impliedFormat":1},{"version":"6d9ef24f9a22a88e3e9b3b3d8c40ab1ddb0853f1bfbd5c843c37800138437b61","affectsGlobalScope":true,"impliedFormat":1},{"version":"1db0b7dca579049ca4193d034d835f6bfe73096c73663e5ef9a0b5779939f3d0","affectsGlobalScope":true,"impliedFormat":1},{"version":"9798340ffb0d067d69b1ae5b32faa17ab31b82466a3fc00d8f2f2df0c8554aaa","affectsGlobalScope":true,"impliedFormat":1},{"version":"f26b11d8d8e4b8028f1c7d618b22274c892e4b0ef5b3678a8ccbad85419aef43","affectsGlobalScope":true,"impliedFormat":1},{"version":"5929864ce17fba74232584d90cb721a89b7ad277220627cc97054ba15a98ea8f","impliedFormat":1},{"version":"763fe0f42b3d79b440a9b6e51e9ba3f3f91352469c1e4b3b67bfa4ff6352f3f4","impliedFormat":1},{"version":"25c8056edf4314820382a5fdb4bb7816999acdcb929c8f75e3f39473b87e85bc","impliedFormat":1},{"version":"c464d66b20788266e5353b48dc4aa6bc0dc4a707276df1e7152ab0c9ae21fad8","impliedFormat":1},{"version":"78d0d27c130d35c60b5e5566c9f1e5be77caf39804636bc1a40133919a949f21","impliedFormat":1},{"version":"c6fd2c5a395f2432786c9cb8deb870b9b0e8ff7e22c029954fabdd692bff6195","impliedFormat":1},{"version":"1d6e127068ea8e104a912e42fc0a110e2aa5a66a356a917a163e8cf9a65e4a75","impliedFormat":1},{"version":"5ded6427296cdf3b9542de4471d2aa8d3983671d4cac0f4bf9c637208d1ced43","impliedFormat":1},{"version":"7f182617db458e98fc18dfb272d40aa2fff3a353c44a89b2c0ccb3937709bfb5","impliedFormat":1},{"version":"cadc8aced301244057c4e7e73fbcae534b0f5b12a37b150d80e5a45aa4bebcbd","impliedFormat":1},{"version":"385aab901643aa54e1c36f5ef3107913b10d1b5bb8cbcd933d4263b80a0d7f20","impliedFormat":1},{"version":"9670d44354bab9d9982eca21945686b5c24a3f893db73c0dae0fd74217a4c219","impliedFormat":1},{"version":"0b8a9268adaf4da35e7fa830c8981cfa22adbbe5b3f6f5ab91f6658899e657a7","impliedFormat":1},{"version":"11396ed8a44c02ab9798b7dca436009f866e8dae3c9c25e8c1fbc396880bf1bb","impliedFormat":1},{"version":"ba7bc87d01492633cb5a0e5da8a4a42a1c86270e7b3d2dea5d156828a84e4882","impliedFormat":1},{"version":"4893a895ea92c85345017a04ed427cbd6a1710453338df26881a6019432febdd","impliedFormat":1},{"version":"c21dc52e277bcfc75fac0436ccb75c204f9e1b3fa5e12729670910639f27343e","impliedFormat":1},{"version":"13f6f39e12b1518c6650bbb220c8985999020fe0f21d818e28f512b7771d00f9","impliedFormat":1},{"version":"9b5369969f6e7175740bf51223112ff209f94ba43ecd3bb09eefff9fd675624a","impliedFormat":1},{"version":"4fe9e626e7164748e8769bbf74b538e09607f07ed17c2f20af8d680ee49fc1da","impliedFormat":1},{"version":"24515859bc0b836719105bb6cc3d68255042a9f02a6022b3187948b204946bd2","impliedFormat":1},{"version":"ea0148f897b45a76544ae179784c95af1bd6721b8610af9ffa467a518a086a43","impliedFormat":1},{"version":"24c6a117721e606c9984335f71711877293a9651e44f59f3d21c1ea0856f9cc9","impliedFormat":1},{"version":"dd3273ead9fbde62a72949c97dbec2247ea08e0c6952e701a483d74ef92d6a17","impliedFormat":1},{"version":"405822be75ad3e4d162e07439bac80c6bcc6dbae1929e179cf467ec0b9ee4e2e","impliedFormat":1},{"version":"0db18c6e78ea846316c012478888f33c11ffadab9efd1cc8bcc12daded7a60b6","impliedFormat":1},{"version":"e61be3f894b41b7baa1fbd6a66893f2579bfad01d208b4ff61daef21493ef0a8","impliedFormat":1},{"version":"bd0532fd6556073727d28da0edfd1736417a3f9f394877b6d5ef6ad88fba1d1a","impliedFormat":1},{"version":"89167d696a849fce5ca508032aabfe901c0868f833a8625d5a9c6e861ef935d2","impliedFormat":1},{"version":"615ba88d0128ed16bf83ef8ccbb6aff05c3ee2db1cc0f89ab50a4939bfc1943f","impliedFormat":1},{"version":"a4d551dbf8746780194d550c88f26cf937caf8d56f102969a110cfaed4b06656","impliedFormat":1},{"version":"8bd86b8e8f6a6aa6c49b71e14c4ffe1211a0e97c80f08d2c8cc98838006e4b88","impliedFormat":1},{"version":"317e63deeb21ac07f3992f5b50cdca8338f10acd4fbb7257ebf56735bf52ab00","impliedFormat":1},{"version":"4732aec92b20fb28c5fe9ad99521fb59974289ed1e45aecb282616202184064f","impliedFormat":1},{"version":"2e85db9e6fd73cfa3d7f28e0ab6b55417ea18931423bd47b409a96e4a169e8e6","impliedFormat":1},{"version":"c46e079fe54c76f95c67fb89081b3e399da2c7d109e7dca8e4b58d83e332e605","impliedFormat":1},{"version":"bf67d53d168abc1298888693338cb82854bdb2e69ef83f8a0092093c2d562107","impliedFormat":1},{"version":"2cbe0621042e2a68c7cbce5dfed3906a1862a16a7d496010636cdbdb91341c0f","affectsGlobalScope":true,"impliedFormat":1},{"version":"e2677634fe27e87348825bb041651e22d50a613e2fdf6a4a3ade971d71bac37e","impliedFormat":1},{"version":"7394959e5a741b185456e1ef5d64599c36c60a323207450991e7a42e08911419","impliedFormat":1},{"version":"8c0bcd6c6b67b4b503c11e91a1fb91522ed585900eab2ab1f61bba7d7caa9d6f","impliedFormat":1},{"version":"8cd19276b6590b3ebbeeb030ac271871b9ed0afc3074ac88a94ed2449174b776","affectsGlobalScope":true,"impliedFormat":1},{"version":"696eb8d28f5949b87d894b26dc97318ef944c794a9a4e4f62360cd1d1958014b","impliedFormat":1},{"version":"3f8fa3061bd7402970b399300880d55257953ee6d3cd408722cb9ac20126460c","impliedFormat":1},{"version":"35ec8b6760fd7138bbf5809b84551e31028fb2ba7b6dc91d95d098bf212ca8b4","affectsGlobalScope":true,"impliedFormat":1},{"version":"5524481e56c48ff486f42926778c0a3cce1cc85dc46683b92b1271865bcf015a","impliedFormat":1},{"version":"68bd56c92c2bd7d2339457eb84d63e7de3bd56a69b25f3576e1568d21a162398","affectsGlobalScope":true,"impliedFormat":1},{"version":"3e93b123f7c2944969d291b35fed2af79a6e9e27fdd5faa99748a51c07c02d28","impliedFormat":1},{"version":"9d19808c8c291a9010a6c788e8532a2da70f811adb431c97520803e0ec649991","impliedFormat":1},{"version":"87aad3dd9752067dc875cfaa466fc44246451c0c560b820796bdd528e29bef40","impliedFormat":1},{"version":"4aacb0dd020eeaef65426153686cc639a78ec2885dc72ad220be1d25f1a439df","impliedFormat":1},{"version":"f0bd7e6d931657b59605c44112eaf8b980ba7f957a5051ed21cb93d978cf2f45","impliedFormat":1},{"version":"8db0ae9cb14d9955b14c214f34dae1b9ef2baee2fe4ce794a4cd3ac2531e3255","affectsGlobalScope":true,"impliedFormat":1},{"version":"15fc6f7512c86810273af28f224251a5a879e4261b4d4c7e532abfbfc3983134","impliedFormat":1},{"version":"58adba1a8ab2d10b54dc1dced4e41f4e7c9772cbbac40939c0dc8ce2cdb1d442","impliedFormat":1},{"version":"2fd4c143eff88dabb57701e6a40e02a4dbc36d5eb1362e7964d32028056a782b","impliedFormat":1},{"version":"714435130b9015fae551788df2a88038471a5a11eb471f27c4ede86552842bc9","impliedFormat":1},{"version":"855cd5f7eb396f5f1ab1bc0f8580339bff77b68a770f84c6b254e319bbfd1ac7","impliedFormat":1},{"version":"5650cf3dace09e7c25d384e3e6b818b938f68f4e8de96f52d9c5a1b3db068e86","impliedFormat":1},{"version":"1354ca5c38bd3fd3836a68e0f7c9f91f172582ba30ab15bb8c075891b91502b7","affectsGlobalScope":true,"impliedFormat":1},{"version":"27fdb0da0daf3b337c5530c5f266efe046a6ceb606e395b346974e4360c36419","impliedFormat":1},{"version":"2d2fcaab481b31a5882065c7951255703ddbe1c0e507af56ea42d79ac3911201","impliedFormat":1},{"version":"afbe24ab0d74694372baa632ecb28bb375be53f3be53f9b07ecd7fc994907de5","impliedFormat":1},{"version":"ca867399f7db82df981d6915bcbb2d81131d7d1ef683bc782b59f71dda59bc85","affectsGlobalScope":true,"impliedFormat":1},{"version":"f1dc4bc37e2476766f29718f5006981009e2c7470ddd538d87be731b8bb24280","affectsGlobalScope":true,"impliedFormat":1},{"version":"9e043a1bc8fbf2a255bccf9bf27e0f1caf916c3b0518ea34aa72357c0afd42ec","impliedFormat":1},{"version":"b4f70ec656a11d570e1a9edce07d118cd58d9760239e2ece99306ee9dfe61d02","impliedFormat":1},{"version":"3bc2f1e2c95c04048212c569ed38e338873f6a8593930cf5a7ef24ffb38fc3b6","impliedFormat":1},{"version":"6e70e9570e98aae2b825b533aa6292b6abd542e8d9f6e9475e88e1d7ba17c866","impliedFormat":1},{"version":"f9d9d753d430ed050dc1bf2667a1bab711ccbb1c1507183d794cc195a5b085cc","impliedFormat":1},{"version":"9eece5e586312581ccd106d4853e861aaaa1a39f8e3ea672b8c3847eedd12f6e","impliedFormat":1},{"version":"47ab634529c5955b6ad793474ae188fce3e6163e3a3fb5edd7e0e48f14435333","impliedFormat":1},{"version":"37ba7b45141a45ce6e80e66f2a96c8a5ab1bcef0fc2d0f56bb58df96ec67e972","impliedFormat":1},{"version":"45650f47bfb376c8a8ed39d4bcda5902ab899a3150029684ee4c10676d9fbaee","impliedFormat":1},{"version":"0225ecb9ed86bdb7a2c7fd01f1556906902929377b44483dc4b83e03b3ef227d","affectsGlobalScope":true,"impliedFormat":1},{"version":"74cf591a0f63db318651e0e04cb55f8791385f86e987a67fd4d2eaab8191f730","impliedFormat":1},{"version":"5eab9b3dc9b34f185417342436ec3f106898da5f4801992d8ff38ab3aff346b5","impliedFormat":1},{"version":"12ed4559eba17cd977aa0db658d25c4047067444b51acfdcbf38470630642b23","affectsGlobalScope":true,"impliedFormat":1},{"version":"f3ffabc95802521e1e4bcba4c88d8615176dc6e09111d920c7a213bdda6e1d65","impliedFormat":1},{"version":"f9ab232778f2842ffd6955f88b1049982fa2ecb764d129ee4893cbc290f41977","impliedFormat":1},{"version":"ae56f65caf3be91108707bd8dfbccc2a57a91feb5daabf7165a06a945545ed26","impliedFormat":1},{"version":"a136d5de521da20f31631a0a96bf712370779d1c05b7015d7019a9b2a0446ca9","impliedFormat":1},{"version":"c3b41e74b9a84b88b1dca61ec39eee25c0dbc8e7d519ba11bb070918cfacf656","affectsGlobalScope":true,"impliedFormat":1},{"version":"4737a9dc24d0e68b734e6cfbcea0c15a2cfafeb493485e27905f7856988c6b29","affectsGlobalScope":true,"impliedFormat":1},{"version":"36d8d3e7506b631c9582c251a2c0b8a28855af3f76719b12b534c6edf952748d","impliedFormat":1},{"version":"1ca69210cc42729e7ca97d3a9ad48f2e9cb0042bada4075b588ae5387debd318","impliedFormat":1},{"version":"f5ebe66baaf7c552cfa59d75f2bfba679f329204847db3cec385acda245e574e","impliedFormat":1},{"version":"ed59add13139f84da271cafd32e2171876b0a0af2f798d0c663e8eeb867732cf","affectsGlobalScope":true,"impliedFormat":1},{"version":"05db535df8bdc30d9116fe754a3473d1b6479afbc14ae8eb18b605c62677d518","impliedFormat":1},{"version":"b1810689b76fd473bd12cc9ee219f8e62f54a7d08019a235d07424afbf074d25","impliedFormat":1},{"version":"24259d3dae14de55d22f8b3d3e96954e5175a925ab6a830dc05a1993d4794eda","impliedFormat":1},{"version":"05069916ab9175271d15f9315a41ab28401561fe0e5f85f295c43538a38bd62e","impliedFormat":1},{"version":"be1cc4d94ea60cbe567bc29ed479d42587bf1e6cba490f123d329976b0fe4ee5","impliedFormat":1},{"version":"42bc0e1a903408137c3df2b06dfd7e402cdab5bbfa5fcfb871b22ebfdb30bd0b","impliedFormat":1},{"version":"9894dafe342b976d251aac58e616ac6df8db91fb9d98934ff9dd103e9e82578f","impliedFormat":1},{"version":"413df52d4ea14472c2fa5bee62f7a40abd1eb49be0b9722ee01ee4e52e63beb2","impliedFormat":1},{"version":"db6d2d9daad8a6d83f281af12ce4355a20b9a3e71b82b9f57cddcca0a8964a96","impliedFormat":1},{"version":"829b9e6028b29e6a8b1c01ddb713efe59da04d857089298fa79acbdb3cfcfdef","impliedFormat":1},{"version":"24f8562308dd8ba6013120557fa7b44950b619610b2c6cb8784c79f11e3c4f90","impliedFormat":1},{"version":"c696aa0753345ae6bdaab0e2d4b2053ee76be5140470860eef7e6cadc9f725a1","impliedFormat":1},{"version":"a86f82d646a739041d6702101afa82dcb935c416dd93cbca7fd754fd0282ce1f","impliedFormat":1},{"version":"ad0d1d75d129b1c80f911be438d6b61bfa8703930a8ff2be2f0e1f8a91841c64","impliedFormat":1},{"version":"ce75b1aebb33d510ff28af960a9221410a3eaf7f18fc5f21f9404075fba77256","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"496bbf339f3838c41f164238543e9fe5f1f10659cb30b68903851618464b98ba","impliedFormat":1},{"version":"5178eb4415a172c287c711dc60a619e110c3fd0b7de01ed0627e51a5336aa09c","impliedFormat":1},{"version":"ca6e5264278b53345bc1ce95f42fb0a8b733a09e3d6479c6ccfca55cdc45038c","impliedFormat":1},{"version":"9e2739b32f741859263fdba0244c194ca8e96da49b430377930b8f721d77c000","impliedFormat":1},{"version":"fb1d8e814a3eeb5101ca13515e0548e112bd1ff3fb358ece535b93e94adf5a3a","impliedFormat":1},{"version":"ffa495b17a5ef1d0399586b590bd281056cee6ce3583e34f39926f8dcc6ecdb5","impliedFormat":1},{"version":"98b18458acb46072947aabeeeab1e410f047e0cacc972943059ca5500b0a5e95","impliedFormat":1},{"version":"361e2b13c6765d7f85bb7600b48fde782b90c7c41105b7dab1f6e7871071ba20","impliedFormat":1},{"version":"c86fe861cf1b4c46a0fb7d74dffe596cf679a2e5e8b1456881313170f092e3fa","impliedFormat":1},{"version":"b6db56e4903e9c32e533b78ac85522de734b3d3a8541bf24d256058d464bf04b","impliedFormat":1},{"version":"24daa0366f837d22c94a5c0bad5bf1fd0f6b29e1fae92dc47c3072c3fdb2fbd5","impliedFormat":1},{"version":"570bb5a00836ffad3e4127f6adf581bfc4535737d8ff763a4d6f4cc877e60d98","impliedFormat":1},{"version":"889c00f3d32091841268f0b994beba4dceaa5df7573be12c2c829d7c5fbc232c","impliedFormat":1},{"version":"65f43099ded6073336e697512d9b80f2d4fec3182b7b2316abf712e84104db00","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","impliedFormat":1},{"version":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881","impliedFormat":1},{"version":"acf5a2ac47b59ca07afa9abbd2b31d001bf7448b041927befae2ea5b1951d9f9","impliedFormat":1},{"version":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881","impliedFormat":1},{"version":"d71291eff1e19d8762a908ba947e891af44749f3a2cbc5bd2ec4b72f72ea795f","impliedFormat":1},{"version":"c0480e03db4b816dff2682b347c95f2177699525c54e7e6f6aa8ded890b76be7","impliedFormat":1},{"version":"27ab780875bcbb65e09da7496f2ca36288b0c541abaa75c311450a077d54ec15","impliedFormat":1},{"version":"b620391fe8060cf9bedc176a4d01366e6574d7a71e0ac0ab344a4e76576fcbb8","impliedFormat":1},{"version":"380647d8f3b7f852cca6d154a376dbf8ac620a2f12b936594504a8a852e71d2f","impliedFormat":1},{"version":"208c9af9429dd3c76f5927b971263174aaa4bc7621ddec63f163640cbd3c473c","impliedFormat":1},{"version":"6459054aabb306821a043e02b89d54da508e3a6966601a41e71c166e4ea1474f","impliedFormat":1},{"version":"a23185bc5ef590c287c28a91baf280367b50ae4ea40327366ad01f6f4a8edbc5","impliedFormat":1},{"version":"bb37588926aba35c9283fe8d46ebf4e79ffe976343105f5c6d45f282793352b2","impliedFormat":1},{"version":"002eae065e6960458bda3cf695e578b0d1e2785523476f8a9170b103c709cd4f","impliedFormat":1},{"version":"c83bb0c9c5645a46c68356c2f73fdc9de339ce77f7f45a954f560c7e0b8d5ebb","impliedFormat":1},{"version":"05c97cddbaf99978f83d96de2d8af86aded9332592f08ce4a284d72d0952c391","impliedFormat":1},{"version":"72179f9dd22a86deaad4cc3490eb0fe69ee084d503b686985965654013f1391b","impliedFormat":1},{"version":"2e6114a7dd6feeef85b2c80120fdbfb59a5529c0dcc5bfa8447b6996c97a69f5","impliedFormat":1},{"version":"7b6ff760c8a240b40dab6e4419b989f06a5b782f4710d2967e67c695ef3e93c4","impliedFormat":1},{"version":"c8f004e6036aa1c764ad4ec543cf89a5c1893a9535c80ef3f2b653e370de45e6","impliedFormat":1},{"version":"dd80b1e600d00f5c6a6ba23f455b84a7db121219e68f89f10552c54ba46e4dc9","impliedFormat":1},{"version":"b064c36f35de7387d71c599bfcf28875849a1dbc733e82bd26cae3d1cd060521","impliedFormat":1},{"version":"6a148329edecbda07c21098639ef4254ef7869fb25a69f58e5d6a8b7b69d4236","impliedFormat":1},{"version":"8de9fe97fa9e00ec00666fa77ab6e91b35d25af8ca75dabcb01e14ad3299b150","impliedFormat":1},{"version":"f63ab283a1c8f5c79fabe7ca4ef85f9633339c4f0e822fce6a767f9d59282af2","impliedFormat":1},{"version":"dba114fb6a32b355a9cfc26ca2276834d72fe0e94cd2c3494005547025015369","impliedFormat":1},{"version":"a54c996c8870ef1728a2c1fa9b8eaec0bf4a8001cd2583c02dd5869289465b10","impliedFormat":1},{"version":"3e7efde639c6a6c3edb9847b3f61e308bf7a69685b92f665048c45132f51c218","impliedFormat":1},{"version":"df45ca1176e6ac211eae7ddf51336dc075c5314bc5c253651bae639defd5eec5","impliedFormat":1},{"version":"3754982006a3b32c502cff0867ca83584f7a43b1035989ca73603f400de13c96","impliedFormat":1},{"version":"a30ae9bb8a8fa7b90f24b8a0496702063ae4fe75deb27da731ed4a03b2eb6631","impliedFormat":1},{"version":"f974e4a06953682a2c15d5bd5114c0284d5abf8bc0fe4da25cb9159427b70072","impliedFormat":1},{"version":"50256e9c31318487f3752b7ac12ff365c8949953e04568009c8705db802776fb","impliedFormat":1},{"version":"7d73b24e7bf31dfb8a931ca6c4245f6bb0814dfae17e4b60c9e194a631fe5f7b","impliedFormat":1},{"version":"413586add0cfe7369b64979d4ec2ed56c3f771c0667fbde1bf1f10063ede0b08","impliedFormat":1},{"version":"06472528e998d152375ad3bd8ebcb69ff4694fd8d2effaf60a9d9f25a37a097a","impliedFormat":1},{"version":"50b5bc34ce6b12eccb76214b51aadfa56572aa6cc79c2b9455cdbb3d6c76af1d","impliedFormat":1},{"version":"b7e16ef7f646a50991119b205794ebfd3a4d8f8e0f314981ebbe991639023d0e","impliedFormat":1},{"version":"42c169fb8c2d42f4f668c624a9a11e719d5d07dacbebb63cbcf7ef365b0a75b3","impliedFormat":1},{"version":"a401617604fa1f6ce437b81689563dfdc377069e4c58465dbd8d16069aede0a5","impliedFormat":1},{"version":"e9dd71cf12123419c60dab867d44fbee5c358169f99529121eaef277f5c83531","impliedFormat":1},{"version":"5b6a189ba3a0befa1f5d9cb028eb9eec2af2089c32f04ff50e2411f63d70f25d","impliedFormat":1},{"version":"d6e73f8010935b7b4c7487b6fb13ea197cc610f0965b759bec03a561ccf8423a","impliedFormat":1},{"version":"174f3864e398f3f33f9a446a4f403d55a892aa55328cf6686135dfaf9e171657","impliedFormat":1},{"version":"824c76aec8d8c7e65769688cbee102238c0ef421ed6686f41b2a7d8e7e78a931","impliedFormat":1},{"version":"75b868be3463d5a8cfc0d9396f0a3d973b8c297401d00bfb008a42ab16643f13","impliedFormat":1},{"version":"15a234e5031b19c48a69ccc1607522d6e4b50f57d308ecb7fe863d44cd9f9eb3","impliedFormat":1},{"version":"d682336018141807fb602709e2d95a192828fcb8d5ba06dda3833a8ea98f69e3","impliedFormat":1},{"version":"6124e973eab8c52cabf3c07575204efc1784aca6b0a30c79eb85fe240a857efa","impliedFormat":1},{"version":"0d891735a21edc75df51f3eb995e18149e119d1ce22fd40db2b260c5960b914e","impliedFormat":1},{"version":"3b414b99a73171e1c4b7b7714e26b87d6c5cb03d200352da5342ab4088a54c85","impliedFormat":1},{"version":"4fbd3116e00ed3a6410499924b6403cc9367fdca303e34838129b328058ede40","impliedFormat":1},{"version":"b01bd582a6e41457bc56e6f0f9de4cb17f33f5f3843a7cf8210ac9c18472fb0f","impliedFormat":1},{"version":"0a437ae178f999b46b6153d79095b60c42c996bc0458c04955f1c996dc68b971","impliedFormat":1},{"version":"74b2a5e5197bd0f2e0077a1ea7c07455bbea67b87b0869d9786d55104006784f","impliedFormat":1},{"version":"4a7baeb6325920044f66c0f8e5e6f1f52e06e6d87588d837bdf44feb6f35c664","impliedFormat":1},{"version":"6dcf60530c25194a9ee0962230e874ff29d34c59605d8e069a49928759a17e0a","impliedFormat":1},{"version":"7274fbffbd7c9589d8d0ffba68157237afd5cecff1e99881ea3399127e60572f","impliedFormat":1},{"version":"1a42d2ec31a1fe62fdc51591768695ed4a2dc64c01be113e7ff22890bebb5e3f","impliedFormat":1},{"version":"1a82deef4c1d39f6882f28d275cad4c01f907b9b39be9cbc472fcf2cf051e05b","impliedFormat":1},{"version":"c5426dbfc1cf90532f66965a7aa8c1136a78d4d0f96d8180ecbfc11d7722f1a5","impliedFormat":1},{"version":"65a15fc47900787c0bd18b603afb98d33ede930bed1798fc984d5ebb78b26cf9","impliedFormat":1},{"version":"9d202701f6e0744adb6314d03d2eb8fc994798fc83d91b691b75b07626a69801","impliedFormat":1},{"version":"de9d2df7663e64e3a91bf495f315a7577e23ba088f2949d5ce9ec96f44fba37d","impliedFormat":1},{"version":"c7af78a2ea7cb1cd009cfb5bdb48cd0b03dad3b54f6da7aab615c2e9e9d570c5","impliedFormat":1},{"version":"1ee45496b5f8bdee6f7abc233355898e5bf9bd51255db65f5ff7ede617ca0027","impliedFormat":1},{"version":"0c7c947ff881c4274c0800deaa0086971e0bfe51f89a33bd3048eaa3792d4876","affectsGlobalScope":true,"impliedFormat":1},{"version":"db01d18853469bcb5601b9fc9826931cc84cc1a1944b33cad76fd6f1e3d8c544","affectsGlobalScope":true,"impliedFormat":1},{"version":"a8f8e6ab2fa07b45251f403548b78eaf2022f3c2254df3dc186cb2671fe4996d","affectsGlobalScope":true,"impliedFormat":1},{"version":"fa6c12a7c0f6b84d512f200690bfc74819e99efae69e4c95c4cd30f6884c526e","impliedFormat":1},{"version":"f1c32f9ce9c497da4dc215c3bc84b722ea02497d35f9134db3bb40a8d918b92b","impliedFormat":1},{"version":"b73c319af2cc3ef8f6421308a250f328836531ea3761823b4cabbd133047aefa","affectsGlobalScope":true,"impliedFormat":1},{"version":"e433b0337b8106909e7953015e8fa3f2d30797cea27141d1c5b135365bb975a6","impliedFormat":1},{"version":"15b36126e0089bfef173ab61329e8286ce74af5e809d8a72edcafd0cc049057f","impliedFormat":1},{"version":"ddff7fc6edbdc5163a09e22bf8df7bef75f75369ebd7ecea95ba55c4386e2441","impliedFormat":1},{"version":"106c6025f1d99fd468fd8bf6e5bda724e11e5905a4076c5d29790b6c3745e50c","impliedFormat":1},{"version":"a57b1802794433adec9ff3fed12aa79d671faed86c49b09e02e1ac41b4f1d33a","impliedFormat":1},{"version":"ad10d4f0517599cdeca7755b930f148804e3e0e5b5a3847adce0f1f71bbccd74","impliedFormat":1},{"version":"1042064ece5bb47d6aba91648fbe0635c17c600ebdf567588b4ca715602f0a9d","impliedFormat":1},{"version":"c49469a5349b3cc1965710b5b0f98ed6c028686aa8450bcb3796728873eb923e","impliedFormat":1},{"version":"4a889f2c763edb4d55cb624257272ac10d04a1cad2ed2948b10ed4a7fda2a428","impliedFormat":1},{"version":"7bb79aa2fead87d9d56294ef71e056487e848d7b550c9a367523ee5416c44cfa","impliedFormat":1},{"version":"72d63643a657c02d3e51cd99a08b47c9b020a565c55f246907050d3c8a5e77fb","impliedFormat":1},{"version":"1d415445ea58f8033ba199703e55ff7483c52ac6742075b803bd3e7bbe9f5d61","impliedFormat":1},{"version":"d6406c629bb3efc31aedb2de809bef471e475c86c7e67f3ef9b676b5d7e0d6b2","impliedFormat":1},{"version":"27ff4196654e6373c9af16b6165120e2dd2169f9ad6abb5c935af5abd8c7938c","impliedFormat":1},{"version":"24428762d0c97b44c4784d28eee9556547167c4592d20d542a79243f7ca6a73f","impliedFormat":1},{"version":"8c030e515014c10a2b98f9f48408e3ba18023dfd3f56e3312c6c2f3ae1f55a16","impliedFormat":1},{"version":"dafc31e9e8751f437122eb8582b93d477e002839864410ff782504a12f2a550c","impliedFormat":1},{"version":"754498c5208ce3c5134f6eabd49b25cf5e1a042373515718953581636491f3c3","impliedFormat":1},{"version":"9c82171d836c47486074e4ca8e059735bf97b205e70b196535b5efd40cbe1bc5","impliedFormat":1},{"version":"f56bdc6884648806d34bc66d31cdb787c4718d04105ce2cd88535db214631f82","impliedFormat":1},{"version":"633d58a237f4bb25ec7d565e4ffa32cecdcee8660ac12189c4351c52557cee9e","impliedFormat":1},{"version":"2e4f37ffe8862b14d8e24ae8763daaa8340c0df0b859d9a9733def0eee7562d9","impliedFormat":1},{"version":"13283350547389802aa35d9f2188effaeac805499169a06ef5cd77ce2a0bd63f","impliedFormat":1},{"version":"ce791f6ea807560f08065d1af6014581eeb54a05abd73294777a281b6dfd73c2","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"49f95e989b4632c6c2a578cc0078ee19a5831832d79cc59abecf5160ea71abad","impliedFormat":1},{"version":"9666533332f26e8995e4d6fe472bdeec9f15d405693723e6497bf94120c566c8","impliedFormat":1},{"version":"ce0df82a9ae6f914ba08409d4d883983cc08e6d59eb2df02d8e4d68309e7848b","impliedFormat":1},{"version":"796273b2edc72e78a04e86d7c58ae94d370ab93a0ddf40b1aa85a37a1c29ecd7","impliedFormat":1},{"version":"5df15a69187d737d6d8d066e189ae4f97e41f4d53712a46b2710ff9f8563ec9f","impliedFormat":1},{"version":"e17cd049a1448de4944800399daa4a64c5db8657cc9be7ef46be66e2a2cd0e7c","impliedFormat":1},{"version":"43fa6ea8714e18adc312b30450b13562949ba2f205a1972a459180fa54471018","impliedFormat":1},{"version":"6e89c2c177347d90916bad67714d0fb473f7e37fb3ce912f4ed521fe2892cd0d","impliedFormat":1},{"version":"43ba4f2fa8c698f5c304d21a3ef596741e8e85a810b7c1f9b692653791d8d97a","impliedFormat":1},{"version":"4d4927cbee21750904af7acf940c5e3c491b4d5ebc676530211e389dd375607a","impliedFormat":1},{"version":"72105519d0390262cf0abe84cf41c926ade0ff475d35eb21307b2f94de985778","impliedFormat":1},{"version":"8a97e578a9bc40eb4f1b0ca78f476f2e9154ecbbfd5567ee72943bab37fc156a","impliedFormat":1},{"version":"c857e0aae3f5f444abd791ec81206020fbcc1223e187316677e026d1c1d6fe08","impliedFormat":1},{"version":"ccf6dd45b708fb74ba9ed0f2478d4eb9195c9dfef0ff83a6092fa3cf2ff53b4f","impliedFormat":1},{"version":"2d7db1d73456e8c5075387d4240c29a2a900847f9c1bff106a2e490da8fbd457","impliedFormat":1},{"version":"2b15c805f48e4e970f8ec0b1915f22d13ca6212375e8987663e2ef5f0205e832","impliedFormat":1},{"version":"f22d05663d873ee7a600faf78abb67f3f719d32266803440cf11d5db7ac0cab2","impliedFormat":1},{"version":"d93c544ad20197b3976b0716c6d5cd5994e71165985d31dcab6e1f77feb4b8f2","impliedFormat":1},{"version":"35069c2c417bd7443ae7c7cafd1de02f665bf015479fec998985ffbbf500628c","impliedFormat":1},{"version":"a8b1c79a833ee148251e88a2553d02ce1641d71d2921cce28e79678f3d8b96aa","impliedFormat":1},{"version":"126d4f950d2bba0bd45b3a86c76554d4126c16339e257e6d2fabf8b6bf1ce00c","impliedFormat":1},{"version":"7e0b7f91c5ab6e33f511efc640d36e6f933510b11be24f98836a20a2dc914c2d","impliedFormat":1},{"version":"045b752f44bf9bbdcaffd882424ab0e15cb8d11fa94e1448942e338c8ef19fba","impliedFormat":1},{"version":"2894c56cad581928bb37607810af011764a2f511f575d28c9f4af0f2ef02d1ab","impliedFormat":1},{"version":"0a72186f94215d020cb386f7dca81d7495ab6c17066eb07d0f44a5bf33c1b21a","impliedFormat":1},{"version":"2d3cc2211f352f46ea6b7cf2c751c141ffcdf514d6e7ae7ee20b7b6742da313f","impliedFormat":1},{"version":"c75445151ff8b77d9923191efed7203985b1a9e09eccf4b054e7be864e27923d","impliedFormat":1},{"version":"0aedb02516baf3e66b2c1db9fef50666d6ed257edac0f866ea32f1aa05aa474f","impliedFormat":1},{"version":"fa8a8fbf91ee2a4779496225f0312aac6635b0f21aa09cdafa4283fe32d519c5","affectsGlobalScope":true,"impliedFormat":1},{"version":"0e8aef93d79b000deb6ec336b5645c87de167168e184e84521886f9ecc69a4b5","impliedFormat":1},{"version":"56ccb49443bfb72e5952f7012f0de1a8679f9f75fc93a5c1ac0bafb28725fc5f","impliedFormat":1},{"version":"20fa37b636fdcc1746ea0738f733d0aed17890d1cd7cb1b2f37010222c23f13e","impliedFormat":1},{"version":"d90b9f1520366d713a73bd30c5a9eb0040d0fb6076aff370796bc776fd705943","impliedFormat":1},{"version":"88e9caa9c5d2ba629240b5913842e7c57c5c0315383b8dc9d436ef2b60f1c391","impliedFormat":1},{"version":"19df3488557c2fc9b4d8f0bac0fd20fb59aa19dec67c81f93813951a81a867f8","affectsGlobalScope":true,"impliedFormat":1},{"version":"a15cf91ab29d3667801562a95730c5f0d96e1d87dffa00a8a91da0002e89fd2d","affectsGlobalScope":true,"impliedFormat":1},{"version":"bef86adb77316505c6b471da1d9b8c9e428867c2566270e8894d4d773a1c4dc2","impliedFormat":1},{"version":"de7052bfee2981443498239a90c04ea5cc07065d5b9bb61b12cb6c84313ad4ef","impliedFormat":1},{"version":"a3e7d932dc9c09daa99141a8e4800fc6c58c625af0d4bbb017773dc36da75426","impliedFormat":1},{"version":"43e96a3d5d1411ab40ba2f61d6a3192e58177bcf3b133a80ad2a16591611726d","impliedFormat":1},{"version":"4a2edd238d9104eac35b60d727f1123de5062f452b70ed8e0366cb36387dfdfd","impliedFormat":1},{"version":"ca921bf56756cb6fe957f6af693a35251b134fb932dc13f3dfff0bb7106f80b4","impliedFormat":1},{"version":"fee92c97f1aa59eb7098a0cc34ff4df7e6b11bae71526aca84359a2575f313d8","impliedFormat":1},{"version":"0bd0297484aacea217d0b76e55452862da3c5d9e33b24430e0719d1161657225","impliedFormat":1},{"version":"2ab6d334bcbf2aff3acfc4fd8c73ecd82b981d3c3aa47b3f3b89281772286904","impliedFormat":1},{"version":"d07cbc787a997d83f7bde3877fec5fb5b12ce8c1b7047eb792996ed9726b4dde","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"4805f6161c2c8cefb8d3b8bd96a080c0fe8dbc9315f6ad2e53238f9a79e528a6","impliedFormat":1},{"version":"b83cb14474fa60c5f3ec660146b97d122f0735627f80d82dd03e8caa39b4388c","impliedFormat":1},{"version":"f374cb24e93e7798c4d9e83ff872fa52d2cdb36306392b840a6ddf46cb925cb6","impliedFormat":1},{"version":"49179c6a23701c642bd99abe30d996919748014848b738d8e85181fc159685ff","impliedFormat":1},{"version":"b73cbf0a72c8800cf8f96a9acfe94f3ad32ca71342a8908b8ae484d61113f647","impliedFormat":1},{"version":"bae6dd176832f6423966647382c0d7ba9e63f8c167522f09a982f086cd4e8b23","impliedFormat":1},{"version":"20865ac316b8893c1a0cc383ccfc1801443fbcc2a7255be166cf90d03fac88c9","impliedFormat":1},{"version":"c9958eb32126a3843deedda8c22fb97024aa5d6dd588b90af2d7f2bfac540f23","impliedFormat":1},{"version":"461d0ad8ae5f2ff981778af912ba71b37a8426a33301daa00f21c6ccb27f8156","impliedFormat":1},{"version":"e927c2c13c4eaf0a7f17e6022eee8519eb29ef42c4c13a31e81a611ab8c95577","impliedFormat":1},{"version":"fcafff163ca5e66d3b87126e756e1b6dfa8c526aa9cd2a2b0a9da837d81bbd72","impliedFormat":1},{"version":"70246ad95ad8a22bdfe806cb5d383a26c0c6e58e7207ab9c431f1cb175aca657","impliedFormat":1},{"version":"f00f3aa5d64ff46e600648b55a79dcd1333458f7a10da2ed594d9f0a44b76d0b","impliedFormat":1},{"version":"772d8d5eb158b6c92412c03228bd9902ccb1457d7a705b8129814a5d1a6308fc","impliedFormat":1},{"version":"45490817629431853543adcb91c0673c25af52a456479588b6486daba34f68bb","impliedFormat":1},{"version":"802e797bcab5663b2c9f63f51bdf67eff7c41bc64c0fd65e6da3e7941359e2f7","impliedFormat":1},{"version":"8b4327413e5af38cd8cb97c59f48c3c866015d5d642f28518e3a891c469f240e","impliedFormat":1},{"version":"8514c62ce38e58457d967e9e73f128eedc1378115f712b9eef7127f7c88f82ae","impliedFormat":1},{"version":"f1289e05358c546a5b664fbb35a27738954ec2cc6eb4137350353099d154fc62","impliedFormat":1},{"version":"4b20fcf10a5413680e39f5666464859fc56b1003e7dfe2405ced82371ebd49b6","impliedFormat":1},{"version":"1d17ba45cfbe77a9c7e0df92f7d95f3eefd49ee23d1104d0548b215be56945ad","impliedFormat":1},{"version":"f7d628893c9fa52ba3ab01bcb5e79191636c4331ee5667ecc6373cbccff8ae12","impliedFormat":1},{"version":"5b2323ca2d1bd97e1f32f09452908e015b012e0e4f958f649cbe0c8989a3fb4f","impliedFormat":1},{"version":"9f5a0f3ed33e363b7393223ba4f4af15c13ce94fe3dbdaa476afd2437553a7dd","impliedFormat":1},{"version":"46273e8c29816125d0d0b56ce9a849cc77f60f9a5ba627447501d214466f0ff3","impliedFormat":1},{"version":"d663134457d8d669ae0df34eabd57028bddc04fc444c4bc04bc5215afc91e1f4","impliedFormat":1},{"version":"985153f0deb9b4391110331a2f0c114019dbea90cba5ca68a4107700796e0d75","impliedFormat":1},{"version":"3af3584f79c57853028ef9421ec172539e1fe01853296dc05a9d615ade4ffaf6","impliedFormat":1},{"version":"f82579d87701d639ff4e3930a9b24f4ee13ca74221a9a3a792feb47f01881a9c","impliedFormat":1},{"version":"d7e5d5245a8ba34a274717d085174b2c9827722778129b0081fefd341cca8f55","impliedFormat":1},{"version":"d9d32f94056181c31f553b32ce41d0ef75004912e27450738d57efcd2409c324","impliedFormat":1},{"version":"752513f35f6cff294ffe02d6027c41373adf7bfa35e593dbfd53d95c203635ee","impliedFormat":1},{"version":"6c800b281b9e89e69165fd11536195488de3ff53004e55905e6c0059a2d8591e","impliedFormat":1},{"version":"7d4254b4c6c67a29d5e7f65e67d72540480ac2cfb041ca484847f5ae70480b62","impliedFormat":1},{"version":"1a7e2ea171726446850ec72f4d1525d547ff7e86724cc9e7eec509725752a758","impliedFormat":1},{"version":"8c901126d73f09ecdea4785e9a187d1ac4e793e07da308009db04a7283ec2f37","impliedFormat":1},{"version":"db97922b767bd2675fdfa71e08b49c38b7d2c847a1cc4a7274cb77be23b026f1","impliedFormat":1},{"version":"aab290b8e4b7c399f2c09b957666fc95335eb4522b2dd9ead1bf0cb64da6d6ee","impliedFormat":1},{"version":"94fe3281392e1015b22f39535878610b4fa6f1388dc8d78746be3bc4e4bb8950","impliedFormat":1},{"version":"2652448ac55a2010a1f71dd141f828b682298d39728f9871e1cdf8696ef443fd","impliedFormat":1},{"version":"06c25ddfc2242bd06c19f66c9eae4c46d937349a267810f89783680a1d7b5259","impliedFormat":1},{"version":"120599fd965257b1f4d0ff794bc696162832d9d8467224f4665f713a3119078b","impliedFormat":1},{"version":"5433f33b0a20300cca35d2f229a7fc20b0e8477c44be2affeb21cb464af60c76","impliedFormat":1},{"version":"db036c56f79186da50af66511d37d9fe77fa6793381927292d17f81f787bb195","impliedFormat":1},{"version":"bd4131091b773973ca5d2326c60b789ab1f5e02d8843b3587effe6e1ea7c9d86","impliedFormat":1},{"version":"c7f6485931085bf010fbaf46880a9b9ec1a285ad9dc8c695a9e936f5a48f34b4","impliedFormat":1},{"version":"14f6b927888a1112d662877a5966b05ac1bf7ed25d6c84386db4c23c95a5363b","impliedFormat":1},{"version":"6ac6715916fa75a1f7ebdfeacac09513b4d904b667d827b7535e84ff59679aff","impliedFormat":1},{"version":"0427df5c06fafc5fe126d14b9becd24160a288deff40e838bfbd92a35f8d0d00","impliedFormat":1},{"version":"90c54a02432d04e4246c87736e53a6a83084357acfeeba7a489c5422b22f5c7a","impliedFormat":1},{"version":"49c346823ba6d4b12278c12c977fb3a31c06b9ca719015978cb145eb86da1c61","impliedFormat":1},{"version":"bfac6e50eaa7e73bb66b7e052c38fdc8ccfc8dbde2777648642af33cf349f7f1","impliedFormat":1},{"version":"92f7c1a4da7fbfd67a2228d1687d5c2e1faa0ba865a94d3550a3941d7527a45d","impliedFormat":1},{"version":"f53b120213a9289d9a26f5af90c4c686dd71d91487a0aa5451a38366c70dc64b","impliedFormat":1},{"version":"83fe880c090afe485a5c02262c0b7cdd76a299a50c48d9bde02be8e908fb4ae6","impliedFormat":1},{"version":"0a372c2d12a259da78e21b25974d2878502f14d89c6d16b97bd9c5017ab1bc12","impliedFormat":1},{"version":"57d67b72e06059adc5e9454de26bbfe567d412b962a501d263c75c2db430f40e","impliedFormat":1},{"version":"6511e4503cf74c469c60aafd6589e4d14d5eb0a25f9bf043dcbecdf65f261972","impliedFormat":1},{"version":"ec1ca97598eda26b7a5e6c8053623acbd88e43be7c4d29c77ccd57abc4c43999","impliedFormat":1},{"version":"6e2261cd9836b2c25eecb13940d92c024ebed7f8efe23c4b084145cd3a13b8a6","impliedFormat":1},{"version":"a67b87d0281c97dfc1197ef28dfe397fc2c865ccd41f7e32b53f647184cc7307","impliedFormat":1},{"version":"771ffb773f1ddd562492a6b9aaca648192ac3f056f0e1d997678ff97dbb6bf9b","impliedFormat":1},{"version":"232f70c0cf2b432f3a6e56a8dc3417103eb162292a9fd376d51a3a9ea5fbbf6f","impliedFormat":1},{"version":"a47e6d954d22dd9ebb802e7e431b560ed7c581e79fb885e44dc92ed4f60d4c07","impliedFormat":1},{"version":"f019e57d2491c159d47a107fd90219a1734bdd2e25cd8d1db3c8fae5c6b414c4","impliedFormat":1},{"version":"8a0e762ceb20c7e72504feef83d709468a70af4abccb304f32d6b9bac1129b2c","impliedFormat":1},{"version":"d1c9bf292a54312888a77bb19dba5e2503ad803f5393beafd45d78d2f4fe9b48","impliedFormat":1},{"version":"9252d498a77517aab5d8d4b5eb9d71e4b225bbc7123df9713e08181de63180f6","impliedFormat":1},{"version":"cb8d8ef7b9ce8ed3e6f1c814fcbf3f90dab0cb8863079236784fc350746e27c4","impliedFormat":1},{"version":"35e6379c3f7cb27b111ad4c1aa69538fd8e788ab737b8ff7596a1b40e96f4f90","impliedFormat":1},{"version":"1fffe726740f9787f15b532e1dc870af3cd964dbe29e191e76121aa3dd8693f2","impliedFormat":1},{"version":"3be035da7bee86b4c3abf392e0edaa44fc6e45092995eefe36b39118c8a84068","affectsGlobalScope":true,"impliedFormat":1},{"version":"8f828825d077c2fa0ea606649faeb122749273a353daab23924fe674e98ba44c","impliedFormat":1},{"version":"2896c2e673a5d3bd9b4246811f79486a073cbb03950c3d252fba10003c57411a","impliedFormat":1},{"version":"616775f16134fa9d01fc677ad3f76e68c051a056c22ab552c64cc281a9686790","impliedFormat":1},{"version":"65c24a8baa2cca1de069a0ba9fba82a173690f52d7e2d0f1f7542d59d5eb4db0","impliedFormat":1},{"version":"f9fe6af238339a0e5f7563acee3178f51db37f32a2e7c09f85273098cee7ec49","impliedFormat":1},{"version":"407a06ba04eede4074eec470ecba2784cbb3bf4e7de56833b097dd90a2aa0651","impliedFormat":1},{"version":"77e71242e71ebf8528c5802993697878f0533db8f2299b4d36aa015bae08a79c","impliedFormat":1},{"version":"98a787be42bd92f8c2a37d7df5f13e5992da0d967fab794adbb7ee18370f9849","impliedFormat":1},{"version":"5c96bad5f78466785cdad664c056e9e2802d5482ca5f862ed19ba34ffbb7b3a4","impliedFormat":1},{"version":"81d8603ac527e75cfec72bb9391228b58f161c2b33514a9d814c7f3ebd3ef466","impliedFormat":1},{"version":"5f3dc10ae646f375776b4e028d2bed039a93eebbba105694d8b910feebbe8b9c","impliedFormat":1},{"version":"bb0cd7862b72f5eba39909c9889d566e198fcaddf7207c16737d0c2246112678","impliedFormat":1},{"version":"4545c1a1ceca170d5d83452dd7c4994644c35cf676a671412601689d9a62da35","impliedFormat":1},{"version":"320f4091e33548b554d2214ce5fc31c96631b513dffa806e2e3a60766c8c49d9","impliedFormat":1},{"version":"a2d648d333cf67b9aeac5d81a1a379d563a8ffa91ddd61c6179f68de724260ff","impliedFormat":1},{"version":"d90d5f524de38889d1e1dbc2aeef00060d779f8688c02766ddb9ca195e4a713d","impliedFormat":1},{"version":"a3f41ed1b4f2fc3049394b945a68ae4fdefd49fa1739c32f149d32c0545d67f5","impliedFormat":1},{"version":"bad68fd0401eb90fe7da408565c8aee9c7a7021c2577aec92fa1382e8876071a","impliedFormat":1},{"version":"47699512e6d8bebf7be488182427189f999affe3addc1c87c882d36b7f2d0b0e","impliedFormat":1},{"version":"fec01479923e169fb52bd4f668dbeef1d7a7ea6e6d491e15617b46f2cacfa37d","impliedFormat":1},{"version":"8a8fb3097ba52f0ae6530ec6ab34e43e316506eb1d9aa29420a4b1e92a81442d","impliedFormat":1},{"version":"44e09c831fefb6fe59b8e65ad8f68a7ecc0e708d152cfcbe7ba6d6080c31c61e","impliedFormat":1},{"version":"1c0a98de1323051010ce5b958ad47bc1c007f7921973123c999300e2b7b0ecc0","impliedFormat":1},{"version":"4655709c9cb3fd6db2b866cab7c418c40ed9533ce8ea4b66b5f17ec2feea46a9","impliedFormat":1},{"version":"87affad8e2243635d3a191fa72ef896842748d812e973b7510a55c6200b3c2a4","impliedFormat":1},{"version":"ad036a85efcd9e5b4f7dd5c1a7362c8478f9a3b6c3554654ca24a29aa850a9c5","impliedFormat":1},{"version":"fedebeae32c5cdd1a85b4e0504a01996e4a8adf3dfa72876920d3dd6e42978e7","impliedFormat":1},{"version":"3eecb25bb467a948c04874d70452b14ae7edb707660aac17dc053e42f2088b00","impliedFormat":1},{"version":"cdf21eee8007e339b1b9945abf4a7b44930b1d695cc528459e68a3adc39a622e","impliedFormat":1},{"version":"330896c1a2b9693edd617be24fbf9e5895d6e18c7955d6c08f028f272b37314d","impliedFormat":1},{"version":"1d9c0a9a6df4e8f29dc84c25c5aa0bb1da5456ebede7a03e03df08bb8b27bae6","impliedFormat":1},{"version":"84380af21da938a567c65ef95aefb5354f676368ee1a1cbb4cae81604a4c7d17","impliedFormat":1},{"version":"1af3e1f2a5d1332e136f8b0b95c0e6c0a02aaabd5092b36b64f3042a03debf28","impliedFormat":1},{"version":"30d8da250766efa99490fc02801047c2c6d72dd0da1bba6581c7e80d1d8842a4","impliedFormat":1},{"version":"03566202f5553bd2d9de22dfab0c61aa163cabb64f0223c08431fb3fc8f70280","impliedFormat":1},{"version":"5f0292a40df210ab94b9fb44c8b775c51e96777e14e073900e392b295ca1061b","impliedFormat":1},{"version":"bc9ee0192f056b3d5527bcd78dc3f9e527a9ba2bdc0a2c296fbc9027147df4b2","impliedFormat":1},{"version":"8627ad129bcf56e82adff0ab5951627c993937aa99f5949c33240d690088b803","impliedFormat":1},{"version":"1de80059b8078ea5749941c9f863aa970b4735bdbb003be4925c853a8b6b4450","impliedFormat":1},{"version":"1d079c37fa53e3c21ed3fa214a27507bda9991f2a41458705b19ed8c2b61173d","impliedFormat":1},{"version":"5bf5c7a44e779790d1eb54c234b668b15e34affa95e78eada73e5757f61ed76a","impliedFormat":1},{"version":"5835a6e0d7cd2738e56b671af0e561e7c1b4fb77751383672f4b009f4e161d70","impliedFormat":1},{"version":"5c634644d45a1b6bc7b05e71e05e52ec04f3d73d9ac85d5927f647a5f965181a","impliedFormat":1},{"version":"4b7f74b772140395e7af67c4841be1ab867c11b3b82a51b1aeb692822b76c872","impliedFormat":1},{"version":"27be6622e2922a1b412eb057faa854831b95db9db5035c3f6d4b677b902ab3b7","impliedFormat":1},{"version":"a68d4b3182e8d776cdede7ac9630c209a7bfbb59191f99a52479151816ef9f9e","impliedFormat":99},{"version":"39644b343e4e3d748344af8182111e3bbc594930fff0170256567e13bbdbebb0","impliedFormat":99},{"version":"ed7fd5160b47b0de3b1571c5c5578e8e7e3314e33ae0b8ea85a895774ee64749","impliedFormat":99},{"version":"63a7595a5015e65262557f883463f934904959da563b4f788306f699411e9bac","impliedFormat":1},{"version":"ecbaf0da125974be39c0aac869e403f72f033a4e7fd0d8cd821a8349b4159628","impliedFormat":1},{"version":"4ba137d6553965703b6b55fd2000b4e07ba365f8caeb0359162ad7247f9707a6","impliedFormat":1},{"version":"ceec3c81b2d81f5e3b855d9367c1d4c664ab5046dff8fd56552df015b7ccbe8f","affectsGlobalScope":true,"impliedFormat":1},{"version":"8fac4a15690b27612d8474fb2fc7cc00388df52d169791b78d1a3645d60b4c8b","affectsGlobalScope":true,"impliedFormat":1},{"version":"064ac1c2ac4b2867c2ceaa74bbdce0cb6a4c16e7c31a6497097159c18f74aa7c","impliedFormat":1},{"version":"3dc14e1ab45e497e5d5e4295271d54ff689aeae00b4277979fdd10fa563540ae","impliedFormat":1},{"version":"1d63055b690a582006435ddd3aa9c03aac16a696fac77ce2ed808f3e5a06efab","impliedFormat":1},{"version":"b789bf89eb19c777ed1e956dbad0925ca795701552d22e68fd130a032008b9f9","impliedFormat":1},"85ae5aee75f011967cf2d25cbc342f62d69314e9d925f7f4aa3456fc2cffcca6",{"version":"d238747e88c8c708451fa6f01ca63893f0396c43d072ec0c7c61f63eaf201789","impliedFormat":99},{"version":"f3d73901e4383f84add3a98573a2738ac5d0cbc648697c302b69b26b75ee140f","impliedFormat":99},{"version":"4acccd722f80edbf731840b8363e17f18f679434a4578ee44f1d3b70c67d858c","impliedFormat":99},{"version":"b3fae73d7dd47d6be5831e14cfa75be9ad8ad5da6ca1f1777bb30be81d744d2b","impliedFormat":99},{"version":"c2ea0cb5e8f8b454f942b3da57e88327cef84016971b28a6b0937475fc815f83","signature":"9c0eeb8de8dfdfb63ebcef09564c84ae1f6b6187c8e8e274fc5b0ee0a2c8432b"},{"version":"b34209befaf07b7cc1932e5cc137ce121cbc9f892551126962d9e908be91adb4","impliedFormat":1},{"version":"32727845ab5bd8a9ef3e4844c567c09f6d418fcf0f90d381c00652a6f23e7f6e","impliedFormat":1},{"version":"2c0b5ace721ddf7314b622bbad664a9958cfd1068422dbed5cdb760cba1c7f0c","impliedFormat":1},{"version":"7a8ec10b0834eb7183e4bfcd929838ac77583828e343211bb73676d1e47f6f01","impliedFormat":1},{"version":"707332817d714a4277d2d386d9c209cdb2137313284c65621849a12f413aaf5e","affectsGlobalScope":true,"impliedFormat":1},{"version":"3f00324f263189b385c3a9383b1f4dae6237697bcf0801f96aa35c340512d79c","impliedFormat":1},{"version":"ec8997c2e5cea26befc76e7bf990750e96babb16977673a9ff3b5c0575d01e48","impliedFormat":1},{"version":"821722285894d0cb2c5f56ec6bbf912b902ccff75255e482237374a2141fa3ad","signature":"c2b8fdddf46a684b2230e08665f6679f3a00186ea2c29a29c6ac9a017c162326"},{"version":"cafc6bda1d830c9df85af7357f6fe5f32d2df862cbdc27a975da591f81ed03e5","signature":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881"},{"version":"03981a348c4473a6a0bbaf606b651043860c8fc3efd7786bc02c4a1e05bf37b1","impliedFormat":99},{"version":"fb82344c312fd920a25c33ae4e0381023f46ef1432775cda1d9ab50077e639a8","impliedFormat":99},{"version":"e0037499acbd201cd60956a4d54ee45e4953cd60f80a2d8acb1bd13c9b134842","impliedFormat":99},{"version":"92339882b71c2ec1f48f82fe70d4ccd003822c4959169f0bab4f1ed0e99dd486","impliedFormat":99},{"version":"d627151917233bf28874a54e2478a6c5e15ef92b7aa8ed0500ca663d1510ce26","impliedFormat":99},{"version":"b83ed62180881087ad8d0bbcaf9c1e18c1bf54c2e7746aa14091334ecf5064f1","signature":"f16c45978bca52f9e6e15e30cb2a644c14a8f12ef7e7883955c0e855a1461639"},{"version":"1506833b09415d814e6904736b77e3cfa9c314d3e8e9608a45402b45cc1d445e","signature":"b5921651dd7f84bf735c77ba7f97a48389e53930d65916f7ac64ae0423c39d81"},{"version":"3f20dbe66f579955935fd0087811cb36ddc84114b894899994f2c540859b645b","signature":"86bd58c9db702e6d85d09d5f2c048e41d1a46879f779e682616e2566ea2db90b"},{"version":"52d0b34f865c3261d992c38f235278e45d1cc5b0706df8a3833bb65c02c539ee","signature":"70b83359a8592fd5bd75c234e3f94f3190a7d16a5d98c543e5fa6fa09a922637"},{"version":"1d4fea28255fec3900e4fa87b50f964dcb2f8c4b57db18fbacb0622fa76a66c3","signature":"d1560f98cd525aba422fab9d0eab88a99d688535f9fe3e9571ad07107150658e"},{"version":"a6a73e063520c9b6f5366304198dd85932f8883a4a6af92b9593a759e4e1c915","signature":"89aad0b689a67c22ccf4d9286189d9100d12392a33cc1e3e4c82e33b0f5532ae"},{"version":"58347b71d621efa402f085188b5eb1d50ed2e5d59a8244d93fef9bc348132696","signature":"52d8766ccab59f3b1886174386c40c467d39ec131d95db874278e5caa0435ff6"},{"version":"dcd039568bf735bef587e81103259821f4075276b00b09b0a953bdd3993382b3","signature":"07b872bf818081b560e585efa3abe6791f40a56e690bedde9cb5e6533bc9dd59"},{"version":"007680c685324a5fd9410f187afb475527f6dbcbee59c59265128bad0378e9a4","signature":"ab4f78ab1262fc757477b389dc41e2059a98fbfc2f126e908ad968e24edf2208"},{"version":"73cd7d6e4cf95533c4773d70a053560ede25412e8dc3fe78899295d2772f5256","signature":"9cf6dcf6fdcc94f8e2883f3b5e55cafe601eff468954d53710503bd1c2877c65"},{"version":"a7d595f18175110b5d8d0fa0d84e7353089073715a2260651fde382c1d937cd5","signature":"43bf088ea02b5e1c3ed20cb3c09f838865b8cf7541483947a7d67d32b92c43fe"},{"version":"825d8bf942dbc5fdd8da71cef6e8f75608e81e19de6176fbeebdbc4ac8a8dd75","signature":"dfd5af6b0313b9befc7d45c6ffa3f928cd0f2dba7b7ebec0b46f6d664d05bb66"},{"version":"c57b441e0c0a9cbdfa7d850dae1f8a387d6f81cbffbc3cd0465d530084c2417d","impliedFormat":99},{"version":"8b15d05f236e8537d3ecbe4422ce46bf0de4e4cd40b2f909c91c5818af4ff17a","impliedFormat":1},{"version":"982bf16c5d13d9ab58c3d3a6485c39fe44f3796f8f5163d880f8818432b22ee0","signature":"512960c0e955a2324b34354dac25e3e4d431a1af4cd33077935eda5e95c8b7e1"},{"version":"24e67694b51913f4eb83edbfc903698b674703dd5f8d063b928a1b3203e0d527","signature":"798afaa1b742e975b16c945bd2472b02d83e1345eb4aea3620006a2a0d9b4a85"},{"version":"e1ddd93abacb2bba2fb81fe92d7eb871db95fc3ae5b4a59078d8d48175a5115d","signature":"dadf21a731c9db354c7bf911eeeef1e5c41d3ebcbb065ed060870a1d90bf1e79"},{"version":"70594d601ac028d97c2ba4fc55d0ab705e481cf98c3df8cb9e18b0081672c1bd","signature":"c4191a61e410a50f7503c543ad6486782d8f5cc149dbaa70e60934a067646bb7"},{"version":"4dc481ce5f4588cc7c9c3f7c7bb99407321b774e0e6db995f924f440149b101c","signature":"523cbf15f5b12fdc02dbcf3f59602623f8b49c4cc351678ce8b0106575cdddbf"},{"version":"d1f1e0d62cb8d8d1e04c26e14de842d8a151f75812d81b046c65b5d1fe8e4b27","signature":"512960c0e955a2324b34354dac25e3e4d431a1af4cd33077935eda5e95c8b7e1"},{"version":"5b066e9723a0825f49eb8f3d0cb54fa1afde3870a0237a5a254f4a42a358fb6e","signature":"49df9a46ebdc372b3fa4df4ccc8425c638bd56e72dee2cfff3ea1e97d2c794de"},{"version":"a9373d52584b48809ffd61d74f5b3dfd127da846e3c4ee3c415560386df3994b","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"2c57db2bf2dbd9e8ef4853be7257d62a1cb72845f7b976bb4ee827d362675f96","impliedFormat":99},{"version":"f7aa45a83c6b92541437a989e435bc06234dd42d445831d3ddb9df6e6d444260","impliedFormat":1},{"version":"894eb30992723a15e3ae75c46a3bf8808a526f5b3bff2c61c78f4d3e8d521cb8","signature":"c9e66c79207c3be6fa9cda6bf6f96476f6432d60a67bb823178c5c5bbc1ecb95"},{"version":"a346701ad6dcdaa58e388fe0995fc5304c09c395b8cba68ed872780f8c102004","impliedFormat":99},{"version":"2fbe402f0ee5aa8ab55367f88030f79d46211c0a0f342becaa9f648bf8534e9d","impliedFormat":1},{"version":"b94258ef37e67474ac5522e9c519489a55dcb3d4a8f645e335fc68ea2215fe88","impliedFormat":1},{"version":"d5793bd9966c2082ad4ec484f7e5a699e2a94d732b1ac2b3b3899535f53ae255","signature":"2d2bb6f362ed85323154cb45c95628affc06e92a2e41f70e6eedec1cfab7d1a6"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"7ec047b73f621c526468517fea779fec2007dd05baa880989def59126c98ef79","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"8dd450de6d756cee0761f277c6dc58b0b5a66b8c274b980949318b8cad26d712","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"6b5f886fe41e2e767168e491fe6048398ed6439d44e006d9f51cc31265f08978","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"56a87e37f91f5625eb7d5f8394904f3f1e2a90fb08f347161dc94f1ae586bdd0","impliedFormat":99},{"version":"6b863463764ae572b9ada405bf77aac37b5e5089a3ab420d0862e4471051393b","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"904d6ad970b6bd825449480488a73d9b98432357ab38cf8d31ffd651ae376ff5","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"1179ef8174e0e4a09d35576199df04803b1db17c0fb35b9326442884bc0b0cce","impliedFormat":99},{"version":"748e35b65a16dfcf9c919ef33634332b89863b87429ba94424cadc3d87b27bbb","signature":"d77c731b000c1abdf6097fdc49718bdab8e373595417be6f898c3d83eedaea1e"},{"version":"6b278654c8265f46ba0cff3373e4a339d12f3c0e0cdcd7ce019502194161a6fb","signature":"3d2c0cc03db7d29147810b60ba10df1a5e86ebbd8b1d2782d924f80f212ca534"},{"version":"097735fbb69c93e3552d60d8080983f717b2f92d3f377d4c031dadce78611ad7","signature":"bd4f71826c8189a0e59d664e81a790582c93812ed97a3b9857f02aa3a0d0c4a9"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"68b6a7501a56babd7bcd840e0d638ee7ec582f1e70b3c36ebf32e5e5836913c8","impliedFormat":99},{"version":"7a14bf21ae8a29d64c42173c08f026928daf418bed1b97b37ac4bb2aa197b89b","impliedFormat":99},{"version":"711dbe2de6452fe53027615421afc6f5941533aacc6fb3e9a831635bb0f23ced","signature":"20f5c6fda7d5906e7abca36cb5068de741c18155bbe26f5aca1e1c29ca5e2f42"},{"version":"89041c0832cb85e54623db6931f6887f1eab666d895d58acb9cae843f6c8f317","signature":"cbf221f62f476e7d8744b5371ff3e302e70609d47d28eec8d01def18095a3e6d"},{"version":"1100f3eab8432605642b8cead539c936179c53c905b212b488b295db2bf6e177","signature":"fe4ceb08d9067ccba5e917a320e68f5b6c3e371eeb6cfc352a1035b278585100"},{"version":"aad6e9accea5f152823a1f334386d8772117925d93b0321c188255348e6786c5","signature":"47e9bd2b0b35ac80d8c2e8d479ba18e1c8ade25abb6f719a0fa0cf043071af51"},{"version":"441ad397d63695d036d3bb29b4a3325517d6594bc149f395a4fe6dd0f6414621","signature":"5444793155d4c4d1787892fe2e0834da07e84d46d410943060d4ee2523dd5650"},{"version":"9703848fac4b9cb3a88bff55375c612d3b20d618e831bba6a8a7d6cd135f418a","signature":"d218480e5404383f56129873277eaab3713141d18e5a5a5152b5c811a968fed2"},{"version":"9d3b774857a2faa0c5bff8be5bfeda4f2b10b03fab7ff952dedaea2e7da4b00a","signature":"03013e8ee349125d195f2f2f4e2441f048fa0b2d632c012b5237f13a748a1362"},{"version":"5cc551ff9930a78448f3d9df99c0beaa3ce0260d24e0ee49dfe61746f1567658","signature":"b263faedc3a538c1e9fd04b26abcb84c76749838cefb983250235c18ee26a4e4"},{"version":"665ce9831a82b74d32fe0cba828764efb5933c121b0b6631a6ae745488443077","signature":"5db5ecf7dfa196724d2a1910421cc5f97682b20b44c1e3fe43aa53ae12486238"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"71acd198e19fa38447a3cbc5c33f2f5a719d933fccf314aaff0e8b0593271324","impliedFormat":99},{"version":"4db2dc92c77cf9107c5413328b05788d20525bc0cd58d92250c8ec40371266a9","signature":"7711adec5eed0b4cb819cae62ea768204c4bd260fa3ee1aceb586358db5f6aa0"},{"version":"a0038a98190dcfbd618ab99a7430869deed2fa9a2db89bc90137d1fb755add0c","signature":"11e7726a4cbc9a4449a13a8346612e4d5fb4b74da64393439aa3a8b3928f07fc"},{"version":"3eafab5fd6347f18cd18abf33ba587c143f54a700612fdce564782055d025235","signature":"5e9a89314155e7de1d26433e87ea1dba527b602b4b5e9cbb785c33ee86d78c9f"},{"version":"e9319a9078bd527589afecfedd58e59d4b64890757fef8645343abe37735d67e","signature":"e8819c34884d48b616883d92da940fe3f4f4594774007dd740c5442448a336be"},{"version":"d39e9d09259084836a02a6cfc4f9f673c2ca24c571ce6aafbc834937aefe403b","signature":"2bf977e792ee40b3c117ce5868120f3b2fe139e77ce4c49f40290aa63d73fc71"},{"version":"caa3a1b62cc032f75a5540bf410385ba01789480d05fdb971af29e79405c1fef","signature":"02a2f2db8eced0cbd444b23d9c10c6701502f1d01eb11ea7d9c3e0d4bdb59e5e"},{"version":"85e75abb2b960333554d87b59c2c93837bcdac57fc8f5bec08e3785dfcdbca85","signature":"a013754e9c9372195578014767d9daa25f3a37a2cac34b96228225fbf6ba5c86"},{"version":"ce493aa019d7455c3df1b9186f634f767fe1fb710d1a7f9d699328926046f52d","signature":"db4451a74570e9d7a3fa34678c2b209d0672ad63e961294b91caa56200e50ebd"},{"version":"ce3eb5532a2526f8da8950a68a6b289d4b152ee6fba2712725d6b4131c15d1b0","signature":"625af19b1393d21209386a7fb51f41fcb0680d81851e6622bd47e0250aac10e4"},"8d2fadd01c0b0728b6901ca369c34284c6a82be6856561b5e6cc38c9a6f5e591",{"version":"c1f887932e7b4c903a217018a90da79d09b84e40de2fd7efac3eb9439ca72702","signature":"b51a28810590d2e1702f7b2f87379f777cbe22fae892b5101c09d1b87b492bb3"},{"version":"d4c16375decc58fc500aafca0793e6f4f89efc6173f9714112ce7ad3c891d85d","signature":"97e8b5455bb1a3c1a0fb8b2234bd5d71deb08e860406d5f8f01b93c8c2c27e98"},{"version":"f8a1781244d0365c586fd2836a6489937db097f699f0afe255c14f2118ead13d","signature":"82ea000610fcca063cd4626d04ca441f65445309fc9f908330b6b91cdd89328f"},{"version":"8e0022d7b3cec030a50a6ca8ba96dc766b51cc8bbc196cebe4ff95a8d8c87c7c","signature":"db237ab9ea2abad36ca0a95b8bdd054b19502c48d8fa851d8a16a1cc0e92151c"},{"version":"9e83d6fa312db9fae9b5b472524b8945083e2f7171e177a75f3a32fcd3b6323a","signature":"72d5ca6a1176bb4cb59efc995e87b53c90c6ce78f96573237e902232df3582c8"},{"version":"9ac6e7292869620833c36f45b87f3c589dce6adcc69eeba7962578fea77803a4","signature":"786c484916770ebb92b33590f5576b8f551322c8059b7d7e7910c1f2f34c0bda"},{"version":"8ba94237f2f6781f01dc6463eae2f867b91e912ba550d48cb4a92cde1d55a0bc","signature":"715392cc53d0ad51d001c8b6ff0484f4ff683de1d455b134ce5e9540f0bfa831"},"1fe014dec193c2ab3d7b054aaf9dc1e10dd60a4743251c1cc37a381d4a8e89f6",{"version":"8329a0b50f818665f1aca05ab93c16b103178b463f2949234ee4416bbc7d3fe2","signature":"da208ef0ae1063fab6eb0c3f831cd231fd88733c49d44516ce37eb066ee8200e"},{"version":"a26d74bc8768e134734fa049d5a89fb674a560292f4bf1b39392416dc04cf49e","impliedFormat":99},{"version":"ea7f3d87bb25b8cf26c1b440de31b628c53b5e72e8f1ab1726356bf58acf5946","impliedFormat":99},{"version":"7ec047b73f621c526468517fea779fec2007dd05baa880989def59126c98ef79","impliedFormat":99},{"version":"8dd450de6d756cee0761f277c6dc58b0b5a66b8c274b980949318b8cad26d712","impliedFormat":99},{"version":"6b5f886fe41e2e767168e491fe6048398ed6439d44e006d9f51cc31265f08978","impliedFormat":99},{"version":"f4a1eba860f7493d19df42373ddde4f3c6f31aa574b608e55e5b2bd459bba587","impliedFormat":99},{"version":"6b863463764ae572b9ada405bf77aac37b5e5089a3ab420d0862e4471051393b","impliedFormat":99},{"version":"904d6ad970b6bd825449480488a73d9b98432357ab38cf8d31ffd651ae376ff5","impliedFormat":99},{"version":"2535fc1a5fe64892783ff8f61321b181c24f824e688a4a05ae738da33466605b","impliedFormat":99},{"version":"c9c151ff19977b78e8d6b108f7162f4daef60aea6c9dd4dcf9faa883ec885430","signature":"3bbc2674f9e5d598c0701114b0081a64cbc78fd3928a2d2e652ddfda70124dee"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"dfcf16e716338e9fe8cf790ac7756f61c85b83b699861df970661e97bf482692","impliedFormat":99},{"version":"bb703864a1bc9ca5ac3589ffd83785f6dc86f7f6c485c97d7ffd53438777cb9e","impliedFormat":1},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"2a00cea77767cb26393ee6f972fd32941249a0d65b246bfcb20a780a2b919a21","impliedFormat":99},{"version":"98007168d58f43df4d2428e25ba09e0ee7ace257b3aa1a48fb53cdd33e428c7f","signature":"8aed813c358a5eb08feb1e4808c7f4a6c12b247ad6b2b16f17cd04f94992cf28"},{"version":"8dedd59e5ce4288bb28f7b50cc8716d9b23487e08a13bc399bb53381de9fb786","signature":"daa157691b1d671ea52f53a1128f2c339e01062d2d59c8a11f2e6b8f245cc922"},{"version":"a171f27504ba8bfa244cb257956e01601f6f98a348e0cb94dc77e201260e377f","signature":"34695ed66680ea492a62489b33cfd7bfa9529b696be1bc23384122f471208d00"},{"version":"360323eeb5e485a813491555f88d01eccee9aca2934155b645e6d4b3c029364d","signature":"f652a45b76dab44e3bae0aae50380a5e3f6da298353c6c4459dfed30f8ce04af"},{"version":"a20316a58bc06868301b0ca2c377db742bd242d7ad3997a2d588183e1a222695","signature":"bd64e1827e335dc3e907e0baacd2a9eeb76d709c340daba612e4058a7f368201"},{"version":"f93f0bef2bf02aa2ad3a5cdeb3082af7193fac00d895945ed1ee0c63cd581788","signature":"74f6816979a2b2b36c5532ce6b47da6960b81efc2998be98bd174a1ab7601e20"},{"version":"b7e549353a865d781a98bf988902da8fa7754e3f3387aae43d161a464420a58e","signature":"0d6b97647fbcc1af274577ccf985ec06965ef9ac342b3789156dc0eb1d84cc22"},{"version":"4badb8e0f2fba7a7a55e32d877f93572292b41fb086b2cd2672388c803f00e84","signature":"a77b1deae4fb9f9916400df3926ffc60e1b27657a8c74f1d5f80fb612f63c07f"},{"version":"309ebd217636d68cf8784cbc3272c16fb94fb8e969e18b6fe88c35200340aef1","impliedFormat":1},{"version":"f987c74a4b4baf361afbf22a16d230ee490d662f9aa2066853bb7ebbb8611355","impliedFormat":1},{"version":"1ff91526fcdd634148c655ef86e912a273ce6a0239e2505701561f086678262b","impliedFormat":1},{"version":"bd93f6fc4da70275db4def32903eed2be03547a41857142df63ddfebb9a67bdf","impliedFormat":1},{"version":"8d67b13da77316a8a2fabc21d340866ddf8a4b99e76a6c951cc45189142df652","impliedFormat":1},{"version":"7952419455ca298776db0005b9b5b75571d484d526a29bfbdf041652213bce6f","impliedFormat":1},{"version":"21360500b20e0ec570f26f1cbb388c155ede043698970f316969840da4f16465","impliedFormat":1},{"version":"3a819c2928ee06bbcc84e2797fd3558ae2ebb7e0ed8d87f71732fb2e2acc87b4","impliedFormat":1},{"version":"1765e61249cb44bf5064d42bfa06956455bbc74dc05f074d5727e8962592c920","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"26384fb401f582cae1234213c3dc75fdc80e3d728a0a1c55b405be8a0c6dddbe","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"e0bfe601a9fdf6defe94ed62dc60ac71597566001a1f86e705c95e431a9c816d","impliedFormat":1},{"version":"568b463d762d0df07ed10081293715069168ad7cf6308525a3bb93777b127845","impliedFormat":1},{"version":"6e5857f38aa297a859cab4ec891408659218a5a2610cd317b6dcbef9979459cc","impliedFormat":1},{"version":"add0ce7b77ba5b308492fa68f77f24d1ed1d9148534bdf05ac17c30763fc1a79","impliedFormat":1},{"version":"56ccc6238510b913f5e6c21afdc447632873f76748d0b30a87cb313b42f1c196","impliedFormat":1},{"version":"c1a2e05eb6d7ca8d7e4a7f4c93ccf0c2857e842a64c98eaee4d85841ee9855e6","impliedFormat":1},{"version":"85021a58f728318a9c83977a8a3a09196dcfc61345e0b8bbbb39422c1594f36b","impliedFormat":1},{"version":"d91805544905a40fbd639ba1b85f65dc13d6996a07034848d634aa9edb63479e","impliedFormat":1},{"version":"6042774c61ece4ba77b3bf375f15942eb054675b7957882a00c22c0e4fe5865c","impliedFormat":1},{"version":"5a3bd57ed7a9d9afef74c75f77fce79ba3c786401af9810cdf45907c4e93f30e","impliedFormat":1},{"version":"8610f5dc475d74c4b095aafa0c191548bfd43f65802e6da54b5e526202b8cfe0","impliedFormat":1},{"version":"7b9496d2e1664155c3c293e1fbbe2aba288614163c88cb81ed6061905924b8f9","impliedFormat":1},{"version":"e27451b24234dfed45f6cf22112a04955183a99c42a2691fb4936d63cfe42761","impliedFormat":1},{"version":"58d65a2803c3b6629b0e18c8bf1bc883a686fcf0333230dd0151ab6e85b74307","impliedFormat":1},{"version":"e818471014c77c103330aee11f00a7a00b37b35500b53ea6f337aefacd6174c9","impliedFormat":1},{"version":"2fbc91ba70096f93f57e22d1f0af22b707dbb3f9f5692cc4f1200861d3b75d88","impliedFormat":1},{"version":"29f823cbe0166e10e7176a94afe609a24b9e5af3858628c541ff8ce1727023cd","impliedFormat":1},{"version":"1026a02ec0694bc6aa393e4fcf39cc2fdb11702b85eeec2f02fe6f8efd1b5fa9","signature":"5f5a3252eead74517079bea9ae6da6930cd7fe6ef65216047e6659627dfacc7e"},{"version":"985ad4e971494b61b4b12078891c0e941767b792c2d490df3b0f5acaf504b3c5","signature":"5341b1f1a8c5bfa1afc9220afb2bf59d416b6c36eda5459eab10844ff4733854"},{"version":"91b4ce96f6ad631a0a6920eb0ab928159ff01a439ae0e266ecdc9ea83126a195","impliedFormat":1},{"version":"88efe27bebddb62da9655a9f093e0c27719647e96747f16650489dc9671075d6","impliedFormat":1},{"version":"e348f128032c4807ad9359a1fff29fcbc5f551c81be807bfa86db5a45649b7ba","impliedFormat":1},{"version":"8ee6b07974528da39b7835556e12dd3198c0a13e4a9de321217cd2044f3de22e","impliedFormat":1},{"version":"5a38140438107de65fa204b3705b83529e225e1b01c68c73fb7fa4e88e5ddfa3","impliedFormat":1},{"version":"5f12132800d430adbe59b49c2c0354d85a71ada7d756e34250a655baa8ad4ae5","impliedFormat":1},{"version":"1996d1cd7d585a8359a35878f67abdd73cc35b1f675c9c6b147b202fdd8dfc3f","impliedFormat":1},{"version":"b16e757e4c35434065120a2b3bf13a518fc9e621dc9c2ed668f91635a9dc4e75","impliedFormat":1},{"version":"0b7ba8784d5de5560adeb015ca6d22d8a9d0920dcb16dd627b40010763f26d85","impliedFormat":1},{"version":"0377607549f9d921e43421851de61264443471afb1f0e86b847872e99bbe3ba0","impliedFormat":1},{"version":"4374cefdde5c6e9bad52b0436e887b8325b8f407c12035194ad02c28f1553a3a","impliedFormat":1},{"version":"9b70cad270593f676aecfe4d1611dc766464f0b8138527b0ebbf1ff773578d69","impliedFormat":1},{"version":"b4f85bfb7e831703ac81737361842f1ae4d924b42c5d1af2bff93cca521de4d1","impliedFormat":1},{"version":"5fea76008a2d537ca09d569ffae4e08b991b4a5ff90e9f4783bc983584454ede","impliedFormat":1},{"version":"21575cdeaca6a2c2a0beb8c2ecbc981d9deb95f879f82dc7d6e325fe8737b5ba","impliedFormat":1},{"version":"40ec58f0fadd0b3981b3d383e1c12fa0680115ae9f018387fc2cfc0bbcf23204","impliedFormat":1},{"version":"849b9e7283b7309a4556c9b90bb8e2dfc27751f157798065bbc513dcddb09a8c","impliedFormat":1},{"version":"10e109212c7be8a9f66e988e5d6c2a8900c9d14bf6beadf5fa70d32ada3425cf","impliedFormat":1},{"version":"2b821aeb31e690092f8eae671dd961a9d0fd598ff4883ce0a600c90e9e8fa716","impliedFormat":1},{"version":"26602933b613e4df3868a6c82e14fffa2393a08531cb333ed27b151923462981","impliedFormat":1},{"version":"f57a588d8f6b3ce5c8b494f2dc759a8885eaee18e80a4952df47de45403fedbe","impliedFormat":1},{"version":"34735727b3fe7a0ed0651a0f88d06449163d1989a2b2de7f047473adc7c1c383","impliedFormat":1},{"version":"a5b13abc88ab3186e713c445e59e2f6eee20c6167943517bc2f56985d89b8c55","impliedFormat":1},{"version":"c8a206a6ba4e32710ebb4a389187772423de0f4f6180b95a7ef1a5a1934c1be6","impliedFormat":1},{"version":"7ae65fe95b18205e241e6695cb2c61c0828d660aca7d08f68781b439a800e6b8","impliedFormat":1},{"version":"c2c8c166199d3a7bd093152437d1f6399d05e458a9ca9364456feecba920cda4","impliedFormat":1},{"version":"369b7270eeeb37982203b2cb18c7302947b89bf5818c1d3d2e95a0418f02b74e","impliedFormat":1},{"version":"94f95d223e2783b0aef4d15d7f6990a6a550fe17d099c501395f690337f7105e","impliedFormat":1},{"version":"039bd8d1e0d151570b66e75ee152877fb0e2f42eca43718632ac195e6884be34","impliedFormat":1},{"version":"9e615a787ac4628fe5bcf3f7b2edf1d487422945a5ce1826024cba04ee41daac","impliedFormat":1},{"version":"5f200be1d6585239093ed367e7a77a5400c76c80a00309ba9b4fc2bb5add9899","impliedFormat":1},{"version":"54e8e74c989105b68db60748270d50ca4330852a490b7c21098876cd6c06ad49","signature":"e8e40e8d9fe75ac0e61a3239829189338d2e18f682afc5e85d641ca6c864993b"},{"version":"4ed810e854887314758640210a5e1f1e3a12ce6016fc00f463f3cbe61772ed10","signature":"768ac3f70eaa70f9bb9388c6742bd67c913045f859b883ed047b2e542f595197"},{"version":"c3d3e266a1712e0038230faf4028fe64d425878f1316b4a04ea24375711ba4e1","signature":"9fd0548e2e0ae45863a450e49f0c5cca978f77096808f9d73ac8b1ef96e0756f"},{"version":"260484c4181267c0d8b95600e781dd1e67027a7673731a20574bb4e49ad13a4f","signature":"c33e556355e91be7918a3c88e00170baa218a85820cad9adbf7cf2fdd4adf5b3"},{"version":"fdbfae7207403251e38517fd91fdffb35e8f7d3941e58ad3515c0005fd53298e","signature":"04088483c561f4acfb8e34ab837a6daf70ccd6e93b71cd9f5f78919c8e41aa9b"},{"version":"9a0ffa4f6d723a51f4371965f906d5f39e97ec80413e9ecabed43e66f3d5cc5c","signature":"089acd7391fe8585299e7e29f6f0c4c8185cf519f805163a0d2fc8f6aa750031"},{"version":"26e21207904a5a08aeb95391f76405a89a388feeaa1e79a3cd250d4997c6a113","signature":"ed4d781d8e359500366f18b8f0ba478f8a89aeb6dd5b75120bb2ee0523257511"},{"version":"b3391ca95c77cae8bfb71c36524937023b885fddc5d7bf52b0b554f3f2e9df55","signature":"e6702e72e8db4ac9781662049c1cba82f6859b62d3c2e03e60fa5f35eb97c95a"},{"version":"c10e12f0eea81257155dd9b9c1c884c3ec172c7dd39fad2b14c8466fb0de2eb8","signature":"9fc9e5682163a9f5687f34a81c45be9dfe418a49843f2ec91013cda2ef69c884"},{"version":"77a3b3d312d7db0df5572cf558bed028a494cce6fe2024dc72d11772b28c96f1","signature":"c27309f8bdf5b2ee37592b8641bf4e1127a61f728215c230b05d8273dec078f7"},{"version":"57ca3d54dcb1d10d3b152460d7f1a47664c211699876080ccdb284a944b9bd4c","signature":"64f679f491ce72393557a76e2f9003aa25bf6e923bc2afbe964167b49772d237"},{"version":"d28d546a6c281eabdf55e7d27dc6ed6624da2999d305041ff1f19f170b9dec1d","signature":"146d15545dd67176ce34e11b7dfbd6d05ed485a9486241c520c4bb9eb631a8c2"},{"version":"31a9984b9580e2588a5edae451c6abbada4081c72c0e8eed2cbf09e47bc886f3","signature":"cc44894b562d47c8570d914ef3722016fb0bc4ebaed5036411a503e606f5a945"},{"version":"1febcd9ff659d6113c5e9a68cfb32e47555fffb2799be52430af08ded21ff84d","signature":"fdffd40e244e33d72848611ab2d1e6fda58c17597eea12719d7d2990b057b3d0"},{"version":"7983641709059d23a092a9282d84aa0561c299f34524397e2486b9369df7746b","signature":"3723342edc83c5309506073f6c0231da3b44ebaf9d57ff80b817d29655ecd33e"},{"version":"053a7a1a336d0882da361b3c63b7b48ae4bf284ae7bb0fa3b5c66f2174625413","signature":"d11c33d82518e60e038f5993fe8dc94b15fc2e6feead064782042369b812e74e"},{"version":"cfbe250c72daafde65b81a94d66b65b2ddc9a1d4a6a8a0eb4cb1232585e29892","signature":"7f5929c9df2d83e29fb75f2d9959c3195425bfa56e341df1c46dfbed4d774717"},{"version":"37fdea562c838a09547d37927c74eeaac84cac0b07a48ae62e45c4f193d3f1d2","signature":"5eb024f17d5b963ed6f7f8f618c6b8539e73e229bc069b6525d67407fa70f56f"},{"version":"cdc90c2306acf0c9d67aa981f35fad4376f49bcad24150f805022684a8b931f8","signature":"be247771537c33159d7aa0f87ef8db4c0806058a66fe8fcc169f38a4f4b0f891"},{"version":"a0be50ef6da9a8cede138827e375ab742b7e99c88feb1c0738b67e15e90f4639","signature":"9f00b9c98835cadac1999b3e2fe06a17fc60c18c157484d7389f4a8ec31120b2"},{"version":"926621ba9cdfc445b9df8ae11b11efbf4a6bb093e3a1a7e963443a912e52745a","signature":"5a98834521ef69f2836c1ac70ba491faf1a6ad74d0665abbd0c8b0f06e7e2865"},{"version":"ed3686bf1d6334f2190d170cc3cd472768a7d752e07382ada6dd5181d150d56f","signature":"d575792cd0642f52cae2448f7d618e8d30cde372e94368c65c0610f4eb2823e8"},{"version":"7fe0b310644a21bbe1b464223a79d2f653e8d74d1c09f4b15c2905fa045e5174","signature":"51b004bcda6dd0f3d874e985a3e64fdacc5038818f6bf7c9c3bec639193e9c2d"},{"version":"6aa2859da46f726a22040725e684ea964d7469a6b26f1c0a6634bb65e79062b0","impliedFormat":99},{"version":"965187bcbeb101020cd84f3ddddd831342e49aaf4ba7c4a89224736ae50dd963","signature":"8415df58a942d4a644c7fb078395d9889ce37fc0c8dc198ec974bfacd62a8b1c"},{"version":"e2a04212ac0ee2a9b078cb4eacb9572273efd997a02cdba4e7c1e3a68f55d179","signature":"4e9f96a9d42dbba4e6da19f18ff178baa27047b0a1fe7fa76c2fcedc60c16469"},{"version":"4925b30d275506c49cf3ff7425a154b45827acd370755a7f4bbc28ddf47dc784","signature":"807728bc50637fb3a3c50e40489080646b60aaa72e6854dc2a512c040344f4e1"},{"version":"039e589178efb20a4a5d9004f7cbc4ea88fb65407ed20634b8a118dfc7b1d025","signature":"a7f0274d906237644c4531f17529e091dbf26a1fdc9242a98395bb7126a20084"},{"version":"9ac2f910798c21b713f28cf3a27edf4759c2a2f84ae48a44e7b7f8e9d5e176a9","signature":"41c77d137f79a1a70de79c52d698350dab0c9552457c18fa52b493c13d3c3b2d"},{"version":"d316d6b1e293a5c3b52765d43baa4ee6a1289f24967d03028bdf17df53559ae6","signature":"5527fd87f57b7db1a7b23f9ed7d701c3b44297f6ae5f5b964c951ad455130d42"},{"version":"39503ac8d6610b06ba5e8260adcd786c698179c4e11d75ff9e54bfb3a86d08f3","signature":"bffbb873e2ebe16ddf4799e9f262849b3875ebc13d86d3da7297f8a917f97592"},{"version":"9d7d1203c3624a3e33370ed3964f0bebcc6c6d7c25802a7efebd9687ee0834d8","signature":"95b8f8b466f1ddb44b87eb52d650cc0f25297d0bfac95f2ad312f0aee84107ad"},{"version":"d9ba094a68e9a2e7c52797aca2344f15ad5f5a042b212043106cd983592e7dd5","signature":"1f86fce8b47ff0b1da8cb845cf097884d1c8321a74cb2c6af6bfee670c23439f"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"4a5aa16151dbec524bb043a5cbce2c3fec75957d175475c115a953aca53999a9","impliedFormat":99},{"version":"d4c744131c6161300510909aafe2c2cb6d819f2c7a8c2aeb75d4317004c7eff7","signature":"1913d3e9a871099126700f506a2c3b8fe9d47857253124e5787055b463b98b4c"},{"version":"06931166ea9511ca83389661363ec90be1bf318822ecc5451acae036940f127b","signature":"d6ddf65af09c5330c9bb37727d6c8ed9108c067e7c673765b37e27b27d66dd04"},{"version":"01f48255add5965d2c9f0c1678855376f551f71f9ad0d2c2f757882d68021d10","signature":"554776f1bc9e684020cd407e516508e844dcf51b52717ce30b6e4f9a1e6f366f"},{"version":"41d1eda81e38bb72eb887b29e41f0c1a2bc6c8f53f9dde39b3668a46382effdb","signature":"f853261ab1c4b8bf8f0eabbe4ec0f1bbd42fd12fb00d52cdf79340238c1019e8"},{"version":"15022b64cf52c20ab8628222ef4b8464336a25137638b39d6208271225646b6e","signature":"c5f6bb3be9ccb34a042bd23cb9826521135259c54c9afa10c84389f83056fa02"},{"version":"5e0453648319b9b3c5ad011fa6c3f9c178ded64ef9e4bf887be08e94261e7eca","signature":"06ea396325a1e8909c69873c9e3552b98f0f978a7d56130b523858e74c051be7"},{"version":"89b0676baf5a061c8d5ce1e1d80e3b02fa4c027ca3c577d49d82dada75402e48","signature":"0d6137c95a67ffd57db626a7de415cc90ea4307d8aac76525502c680d3853036"},{"version":"18874081455df78221becbde75abf5caef957ec17aaa456072b2665adfa96713","signature":"fc4d567fd2c2173fcd829914bbb5ed3a3f6400bf4860331869f315850eb98303"},{"version":"04e74bcb4dcffb60f68e28996a310f39576386db51ee93f1a2a52efad9e0cc5a","signature":"f15525c528f2fb2d83814b552f1f477d8d44572672982ed99da742bcd9b77646"},{"version":"958d8fa5097c7cdd2697e4d0f8f34f1caa06241265badb26851e6691b4bbe5d9","signature":"15f85eb892cf42e31284c1b84e4fded34dda6b57f647ffb8a869071fd3110cf7"},{"version":"db5f8f5659b4d5d2d19ac7cda263927b01525b1d4c39d7b72ddb53cf58df71c9","signature":"b6248c081835f1aab18a92a4d06b8a9fe0077edec8062f3b3b4ee05d8a58da6c"},{"version":"5b85b57aec5f3686f32f58b16fa504f3d151e6262876dfdff51ad8dfac09a77b","signature":"6202a920fda430fdcd1d29658925a6a6cf83b4a6a0bc4127074e481c9111703c"},{"version":"9b663cff1dfbd10aa9fa5543776c731e8b96872a114291d3418ceaad8b14ae33","signature":"450acb295e2d36ed3f94a907f6feaf2307ac39eb969d455ac6dac329ef660562"},"b9107eccee190d80e37633f8b9414394be98ee0a9ef556df3f39fdf71a291af2",{"version":"2f304078088f2f4dad8c89966a7abb2f5989e450ca36bbba6b6ca175b7cd1733","signature":"fa01815d97da0e20aa59b46fb1e69096b102d91a5a471ddcffa4e7105a3b23ce"},{"version":"315871b5f94bbe580a56f42d4e020e174621c52b701bf8a7860aaa49479e0782","signature":"ff837aa7e3ecaf3ca1d66c54dc57d30d03d27267813b2b45010094a988c59f7e"},{"version":"5a1278eaf58ecfd1f14ae0b9e0aecab3b977a8ef009dcef80f5210111243c3c7","signature":"46bee82b298b4aa3aa8ec9ac4cf9c6a0953641c2879ea8a79301222bceeac56c"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"89783bd45ab35df55203b522f8271500189c3526976af533a599a86caaf31362","impliedFormat":99},{"version":"26e6c521a290630ea31f0205a46a87cab35faac96e2b30606f37bae7bcda4f9d","impliedFormat":99},{"version":"798b5337dc147d88c65de01f7221e0bfa04272968a1fce6acc1ec0bef7d9ddb9","signature":"0ae95632387b568863f5432688f3d5b538edb7f0b60efa3e403667dbf4a6f509"},{"version":"8f5cc1f67dc4891ffdefae2fc6f12828a6b0436d89e15469795975ad8013585b","signature":"ce8c9c7ea358cb3d9f7f4c07908665ce3cc5bb54190bb643ada5e4c3178afb5d"},{"version":"f19a50ff750708d9f3d8728ddb15c66546af39d74f8f11efd9ed5995192a3597","signature":"9de2baea4fd338c194f89522177deb7c424a11c3e962ea788d58c281acf8f341"},{"version":"d37725b62beb650214c40974078d0b537a2df531a10bc843595aa3ab0c15fcae","signature":"23040585e4e7d3b80a4ecc2c3b00d8dbeb57d9ddfa9c42a820df8edd92154a74"},{"version":"f467fc85a8b59e7c1bc8a56d795b00b7e080221c286e13218a26d1265b854116","signature":"e65416c124c9f46e7c3821cde9224b2900f734c3763aa7154bce71b8c97a2c0a"},{"version":"96d87913d6fc27df14759c6892fc97bb07c843b52a3e3ef23e2c9cd5f3856f32","signature":"02aba73a5ca1a835386bb3084dd25ac2a664dee48a1f85f850986bb6c7bc3592"},{"version":"0b8dbc733f441b94f847a661e86eb4af60ba2e0563819ba9ccf4a823ec7c134e","signature":"1d9036fab5ea5c0081fffac4bc36f93e2761cf2def8787ad59fb58034d73ee9a"},{"version":"64f579883aebb77433ec6352ab6e3d765bbfa0dc80f10a10ea897ad0fac5124e","signature":"1f2cddfe3e154c9eba4947f585f12ebbca23963d5ab94d8221f357aad890da55"},{"version":"400525db61b02a2a53fee06e0383b49e7d36e4ada0f327ec6fa357f5e64aeb82","signature":"9e645876fae5a325d519b7eb27b55eb6129b1a82e2bf75227ccdca261bc0df6c"},{"version":"49a0273be8bdc9028e675f19b47d372a65051a9fef7a32cc97f62a1268a57ff5","signature":"d1e42eb6a8d589481f2a57dcc70f60d979847255d48843fddfb0cc77e2cd207a"},{"version":"7b7de17c831576b7c9020fb2f66f5fd880c0013f0ff2d348c17d15985c11d2fb","signature":"60e6bc55718711a9a59f002dfa427a25804ed25517969502ae28a9fe1056ea59"},{"version":"0e9899009019aa1b8811aff7647956ceeb69d909714ef4f7d3035e266f8e42bc","signature":"5e49d2f91c18e06a58692ebef1c8ec034927ace7b4178ff55ddaf32f1f36384f"},{"version":"650fe28eb8d23ac40f9cf84ae6f6b0b15c705e878120fae7b9c42bcab02d5f94","signature":"3d4e569c78cbfd985b5d14191a3be2fb758edd28d37dbc2bc07ff5a00af783a3"},{"version":"dea694dbdf31ee8419885c297f679fbcdcb357e1da3a4a48f96dafee731c2c35","signature":"504b9ddc2600d687ed3b0483dd931f1d7576025a4fa0a4fd82b296657817d34f"},"42a2e5d8761a786fecd36bd0c8ac51a6758993ca8c1f7eb0097d5cdc84a8fda1",{"version":"45afb60a416f1d395fb3da84db4a585f486f285388bc88c23f411daf7dcada6c","signature":"3617bf013f449b222d62aa0b208f8f699d242414ea234b900a467ff5332f5aff"},{"version":"2ada2f0d61e31f25cae354b89a716d3ceef61092dcd0c53ac06c43428efd6076","signature":"e10e43e68232aeff5ab844819126d2f6302d2fee63b6296a3c63f488a5e6dbe0"},{"version":"afa47d2eddfc875c84463cbb7756b14bda53cc4101efa0f914404e2becefe5f9","signature":"07d72cbd8937f6b40f5cbd605539d2553756e20c8fd66eebbd468730461cd083"},{"version":"4446850b5665c2f5bc7c4363a6e42256a47a3df4620da09ffd1f84d3b8293f10","signature":"2da657bfb326db428e9d1328473b688da6648efedc0bfdd528718109c202981a"},{"version":"d1ff367c377396feb0ef5b12f1a404a930dcd0f7082bcf8d9276a802d94ef3ab","signature":"f00cb3cf2eb0b87c43e88211235cec90902469631c81f525038b66203f083209"},{"version":"a01059005840236da93d2746b222a25391f2e09a11fd55ffd40b59a638b6d0a9","signature":"3ad3e9740496dae13c2ee0d8b316e6a245059e8c893dae3c7846fced62d8720a"},{"version":"48b94f3b652c68c0f427d19773e6460c6176ee95f0ea9864cb03e8cc9176acf8","signature":"91f51641daa8dadd247163be7a1e293765df88595205afaa7d2678217491783f"},{"version":"e3507ff969a7c1c9d55e0e6a7986d863433ac6fab17e27f5fa6c8d0fd79c15be","impliedFormat":99},{"version":"8bb642bc24d7a21e67124613f77174e377b053b4e50f08d3bb8b4b71c30da185","impliedFormat":99},{"version":"c043623180122dddecf5565e0809ea90426d6fc370454cd2ba1ab99ca3398248","impliedFormat":99},{"version":"70f20697bc3ed03af85920db61fb1e4388fffa37cd2e0c0d937e7608f5608bd1","impliedFormat":99},{"version":"5e35a2a3f0b62ee763fd1d1f13cdec015ea10fb1ed7a670989b1ba49b37ad287","impliedFormat":1},{"version":"b3b5aca751100320745c8bfd826202aed7d753d336448ce2265b9470dfa8a298","impliedFormat":1},{"version":"5fa35c6051059d5ed57cbda5479b593cec15d5405229542042bd583c1e680fb4","impliedFormat":1},{"version":"7df3932c1b8816845e1774538c4e921e196d396b3419e2e18bc973079b4064a3","impliedFormat":1},{"version":"c8a7131a27d7892f009ab03d78dc113582f819c429af2064280bec83c2e7c599","impliedFormat":1},{"version":"19629032a378771a07e93c0ab8253b92cb83e786446f1c0aed01d8f9b96a3fb6","impliedFormat":1},{"version":"fd4b51f120103d53cc03eea9d98d6a1c7e6c07f04847c0658ec925ceeb7667aa","impliedFormat":1},{"version":"53bacb19d6714c3ea41bebf01a34d35468a0ac0c9331d2ffdc411ce452444a2f","impliedFormat":1},{"version":"e2ce339ecc8f65810eda93bb801eb9278f616b653f5974135908df2c30acc5ae","impliedFormat":1},{"version":"234058398306e26bc917e6efba8fb26c9d9f2cfdfbaa17abfcb11138847de081","impliedFormat":1},{"version":"b3ff9aff54c18834bce9690184e69fd44fd5d57273a98a47fbf518b68cc4ec60","impliedFormat":1},{"version":"e6cfcf171b5f7ec0cb620eee4669739ad2711597d0ff7fdb79298dfc1118e66a","impliedFormat":1},{"version":"3dc40ead9c5ac3f164af434069561d6c660e64f77c71ab6ad405c5edc0724a94","impliedFormat":1},{"version":"d5fb34e3200ce13445c603012c0dfbd116317f8d5fef294e11f49d00a859a3d0","impliedFormat":1},{"version":"58fc843cdfd37a8b1ae2cbf3d6d3718d41cdafcbbf17e228bd6a7762a7235bf0","impliedFormat":1},{"version":"a4d0945318f81b27529abcae16d65612decf4164021a0d4d2ec19fbfcbaf1555","impliedFormat":1},{"version":"fbe57f37a07a627af9ae5922c86132677e58689427cc748866a549ef3862f859","impliedFormat":1},{"version":"8df750d51d498be760d538ac9818c7aebea597f21d4937a65fb2ebedd8a976e7","impliedFormat":1},{"version":"5b9c5efb469020fd6a8c6cb8c4b378ef3dc46ad97938ac900882f1d5f237bc91","impliedFormat":1},{"version":"83dc862cd9b7b1a929bcc03e9bbc8690cebc7e29b1edfa263f6fd11b737f19df","impliedFormat":1},{"version":"fffacebbcc213081096e101e64402c9fb772c5b4b36ad5e3d675e8d487c9e8af","impliedFormat":1},{"version":"1b243b5a51dff2bf70b7a6ce368fe7ff845c300027404b5a41a87ce5490cdad0","impliedFormat":1},{"version":"dfb119c12d7d177eb47b98c011677ca852dff82ddbe40ea571e31e04d2b84278","impliedFormat":1},{"version":"e0b50044596bf7b246a9ad7b804cc5ab521f02e89460a017981384895a468f23","impliedFormat":1},{"version":"b303a99933b69d9d6589ac24f215e5d987933782244251a10e62534f08852d94","impliedFormat":1},{"version":"e052b679185d44460040d5ce3d703d503e5f7108cd4e9d057323f307c6c0e42e","impliedFormat":1},{"version":"ddb79ad4350198a188ad3230d2646b4c67467941ddf4022ed01e4511a56d2cd9","impliedFormat":1},{"version":"8b3de2f727cfd97055765350c2e4d50ea322cabb517ff7aa3fa0ad74aab4826e","impliedFormat":1},{"version":"b3e584a57553f573aa01b34bf0d08c4dfefb2b9ede471c70d85207131f0f742f","impliedFormat":1},{"version":"23a24f7efe3c9186a1b05cd9a64a300818dd0716ffbd522d27178ec13dc1f620","impliedFormat":1},{"version":"6849f3dd56770a08b9783d61e3ba6e2d0ba82850a20ae97e1bdcaeb231d2f7fc","impliedFormat":1},{"version":"6fb23beb59f1f5c8dc97bfc012d5edac81ffca1c1b83a91381b4e130e7ce24f3","impliedFormat":1},{"version":"bc759b587b3e7213fc658fe78dbaf7b0e7c0a85f37626823b4bbef063759c406","impliedFormat":1},{"version":"04ed59801192608de22461e38b9f2e300953f1d6d6c05332f19e78e668d6a843","impliedFormat":1},{"version":"bf5cfc96bacabfe71962c32755df63ac499f732571368db3bdd7e144336c50f7","impliedFormat":1},{"version":"4c10770eca2ae9c1d5c97dad5c715b0c65def8699066231851a69fa58aaab3bf","impliedFormat":1},{"version":"c7e7d48913bfa205453911f699307e7ce630deb3c3e68326377bc2ba20abb1f9","impliedFormat":1},{"version":"4b78505d4f7ba7a80b24dae9b9808c2ec3ecb6171af03a4b86a7a0855d7a80c1","impliedFormat":1},{"version":"d09d8ac8da326eb4cf708d3a3937266180fe28e91c3a26e47218425b2ec1851d","impliedFormat":1},{"version":"50c0c2b5e76e48e1168355e3622ca22e939c09867e3deb9b7a260d5f4e8d890c","impliedFormat":1},{"version":"66491ea35e30cc8c11169e5580aef31e30fdf20b39bc22e0847c2c7994e2071b","impliedFormat":1},{"version":"35680fb7f25a165e31e93ea22d106220db4450b1270a135b73f731b66b3d4539","impliedFormat":1},{"version":"5865007a5331be0842d8f0aace163deda0a0672e95389fe6f87b61988478a626","impliedFormat":1},{"version":"dddc865f251a4993b9e23494a9ae0fb58997e0941b1ec774490a272d5a0b29bd","impliedFormat":1},{"version":"76d1f106ef20648708a7d410326b8ad90fc6f7d4cdf0e262edd6bd150676151b","impliedFormat":1},{"version":"6e974c9f7e02b1f1b7c9538619fe25d9d23e4eb5df3102f62f3bb0cb3d735d1a","impliedFormat":1},{"version":"18f3835257e2f87f8dc995c566217c5434d9bc14a6d18e7ca0e2afbfc2f1eca8","impliedFormat":1},{"version":"69055f4f0b1b2df9f0ca89231075c0578975518543100582dd37adb956ad6135","impliedFormat":1},{"version":"c3f85a0f71b64d78e7dfb27a12d10b0cd621745f40752b8e9fa61a7099d4290e","impliedFormat":1},{"version":"0b4b2424b5d19bbac7e7ad9366419746fff0f70001c1867b04440d0031b26991","impliedFormat":1},{"version":"e6d999c047721b80fc44a025370dbc02022390bfcf3c1e05cd200c53720c3f16","impliedFormat":1},{"version":"4fd695c068c325f2eb6effd7a2ed607d04f4ed24b1f7cc006b8325b3eb5bd595","impliedFormat":1},{"version":"c18fb9b8d4a7f41ae537512368ec9028d50b17e33e26c99f864912824b6e8c30","impliedFormat":1},{"version":"2b214fb1c919b0483175967f9cf0809e0ac595a7be41ba5566be27ce3d66cf86","impliedFormat":1},{"version":"ff8ece28a240cb8a29342a8c54efdaf124f93301081afa047bd1e7f6ec2a79e3","impliedFormat":1},{"version":"9b923be7ef4337bbddbd1713b13cf81da9a955034bdf657bb9e60a8fc9b20ac5","affectsGlobalScope":true,"impliedFormat":1},{"version":"527668d62da5909154a74b74a7a9ae59c41ab4a70da76c2f476765308efafb0f","impliedFormat":1},{"version":"e2974b2b0a7ba6384f5f3338d2a6a70170c3002112d6e05ce593d966100bf232","impliedFormat":1},{"version":"cc3738598b5fe875e341f701824403b3cac48c50472c72423d3e236b610fa977","impliedFormat":1},{"version":"f06e49e80942ebd4f352b1d52d51e749cb943e5b7e368cdf0ce15a169cfad5d0","impliedFormat":99},{"version":"adcbd1ed0d1621b7b2998cc3639871b57d85a3f862759d81c8634fbb6f3ec260","impliedFormat":99},{"version":"c982042c9614e12edd22a8ec0ba55c52fb31b41a513e841a0f3916fea6f775ca","impliedFormat":99},{"version":"28004f9370a7177104fe5c71381f4d2ddf8099066ba15ad0264df14135f0210a","impliedFormat":99},{"version":"0d85481bf9d4418ad633806d8d909777749291164161e87d3f76fb68ab1ae4b1","impliedFormat":99},{"version":"26474a5870247854706ee1a1b53846c464fa46d4f0fce6feca43516c6a565ece","impliedFormat":99},{"version":"499060fff17e6127887065c69309b9785808229fa4851185762b434fd191eb8f","impliedFormat":99},{"version":"e8b61ed76ce071a18c16b3d5145c9ec24a79afa4a40e4e70482d420988ad2e92","impliedFormat":99},{"version":"959c15065a76d4dc5e77e5c83dab8bcd52ebaa5779eb4d42fb43a5134c219eca","impliedFormat":99},{"version":"6aba2b87d07562e15164415aeb5ef55e544cfc4ead91c18982e0c5b70739c120","impliedFormat":99},{"version":"876324641782ef0d4123c39ce5b4fe59ddf3dcd8ef747bc06bd935aedf0a71c6","impliedFormat":99},{"version":"0716a38be84ad12588a2ffeb66977b960b6f9ec477473063b61b7fab971bbe4e","impliedFormat":99},{"version":"029fc7882219b11a8d7f0b64a51ecc6cceff45813fb0d5daf793c503a20dffa7","impliedFormat":99},{"version":"5cfb2066d3fe03aa5d6ffad84629bcb1eb4fe7cad46f874afca80aa459962b75","impliedFormat":99},{"version":"0a1b0a946c2dc3dbc3f7b41fab8ca5a3bb5f21fc3965dc07d1cb5af831a962d3","impliedFormat":99},{"version":"0e1a03168fbe0d48c1a558ce495ea48c922f9c2c98658092ef8361bb8c40536a","impliedFormat":99},{"version":"1204aa56ffbdf67afe38cd279d602ff1033fe9dc2110fc8fc219f1deb4b18a5e","impliedFormat":99},{"version":"922f879e741bb05195e598b51a58e3784f34761ee4d92f2f470f57740ffa1b7b","impliedFormat":99},{"version":"a06db219f83fd299973856c648293bcfca1f606a2617b7750f75b13dd28ca5fd","impliedFormat":99},{"version":"8832937a4f608e96d8c7b53fd5c040fd1e2be78dea6ca926b9c16e235f114749","impliedFormat":99},{"version":"60fa62255c9a3fc917f4be2d8c23ded1f3e919f68db44af67f8c67b46014663a","impliedFormat":99},{"version":"ebd64fdcbf908c363ab65ccb1ad9f26d82cd2bbb910fee5a955f3b75f937b1d2","impliedFormat":99},{"version":"608c0d45e9440b26e61a906bcd32ca23db396fa32aa29087db107bee281d70bf","impliedFormat":99},{"version":"c57ff70bc0ae1a2abe4f1a4c8fc8708f7cd99d0de97fac042e0ba9f4970c35db","impliedFormat":99},{"version":"cf5007ed1f1bdd4d9c696370c6fa698eddef590768bbb9807c7b9cb4000a9ec7","impliedFormat":99},{"version":"b96853f733fed9aa8ad28d397e1ec843792749dd8432e7f764edcb5231ec4160","impliedFormat":99},{"version":"6ee0d36f09cff8a99010c8761003a83b910149e5d7b39656f889b2bbbabe0f27","impliedFormat":99},{"version":"b9f6ae525124fa2244c7e5ae3d788d787db47c4dab1beda7809cfb6c47f74968","impliedFormat":99},{"version":"a74c7a2244c60699441eb66577f230112eb56235a0fd7b26451ffe03c999991d","impliedFormat":99},{"version":"a1fc2559d90de9e703fab40ed46ff05a402113d164892c3c4ca192102f136c99","impliedFormat":99},{"version":"514167c3cc3640146a0ede53e59dc82c1d27ad1bc1e134912a0ea2cff69f997c","impliedFormat":99},{"version":"10ce8a11a9beb91431a0246977d0c9342c9f530b6ddaf756a0ad6fef22818b9d","impliedFormat":99},{"version":"269ed3176766758542995bfab9612b921bb47c3b1efd382b3ec843d0e2dc147d","impliedFormat":99},{"version":"f3ec93a448c4bf491bd372962f4c9a402ba97a917ce905ac0251f16c2e03fb43","impliedFormat":99},{"version":"3c7869711e28e33bb715dedb6879707cb54bb91b0ea9e54c9e308ed23be6b8b4","impliedFormat":99},{"version":"abbd33f1c632b4e592fde62769716a5134831f960832d7007a6491e73e4ae109","impliedFormat":99},{"version":"f88a59d7650984e794b40b34303dcedc1c3802acf21429f110c832fedb529dc0","impliedFormat":99},{"version":"2e7ef180b0a117ec2edfc2e349b4ccea4ad63114ea41b0262aa3a6e01cb223f0","impliedFormat":99},{"version":"9e909c7914b218861b219760732ae7a7a880b7d8e5d4feff64eef921ca5efaae","impliedFormat":99},{"version":"de94ac03f309847b4febab46e6a7de3ed68cf6d3a3faf50823def5d1309cbf47","impliedFormat":99},{"version":"97eba2d9706d755314bb85231c44219b707f84209032197255c4c11c6acbfd3c","signature":"496cd22bb4f82c69d05d88ac924b20c9777a3232348707278cf5375b7a1ab576"},{"version":"ae4eef1bf8c13f009f82147f6a2763f2c7472529c7f7fb739f8d45c7bff03a47","signature":"0bb5669ada7a7c579244609dbed2c0db86aebc5c8b89bed00f121775ab60cc49"},{"version":"91f6bdd3a9e945fa50d6a3c005a07b6f15de69415ead01293a039f4603b7523d","signature":"ed59bf3031f5aa24f0ceda91d6c5c9ea5e094f196ba2359409722b13e88de6f8"},{"version":"cfd9b75da29a6a5ba78c0aa4ec57b9bc5e7a55d1acf7de095ed91f662cdf2579","signature":"0c5c3f2215f494cc70301fb873c29441118a9232a5d14eaf6f67ed0dc2317885"},{"version":"473f734af60adb3d6962b0d457063f709fd4570d7c18ed09b50efee7ff9615ce","signature":"b098e49412a79e18117a33c5ebf61cb00b5ab79a0b296528fe7ad705b9bdd013"},{"version":"7fc745acebbee6e62e1d9498a48328d2d8b730a0e4cee78a6349a1be43be7d80","signature":"bd2ee593357e30f039c0a1e7e6901eab64ce342549240e0724ff461e11061584"},{"version":"f74bec68dd458976ea06f05ebdb4cc5b0e42e5242e5361edf0e5ec6e25dd717b","signature":"709605705d4907db12fa43a49e08de13bc875b40e469640cfca3ab72721c87b4"},{"version":"4d7d964609a07368d076ce943b07106c5ebee8138c307d3273ba1cf3a0c3c751","impliedFormat":99},{"version":"0e48c1354203ba2ca366b62a0f22fec9e10c251d9d6420c6d435da1d079e6126","impliedFormat":99},{"version":"0662a451f0584bb3026340c3661c3a89774182976cd373eca502a1d3b5c7b580","impliedFormat":99},{"version":"68219da40672405b0632a0a544d1319b5bfe3fa0401f1283d4c9854b0cc114ce","impliedFormat":99},{"version":"ee40ce45ec7c5888f0c1042abc595649d08f51e509af2c78c77403f1db75482a","impliedFormat":99},{"version":"7841bca23a8296afd82fd036fc8d3b1fed3c1e0c82ee614254693ccd47e916fc","impliedFormat":99},{"version":"b09c433ed46538d0dc7e40f49a9bf532712221219761a0f389e60349c59b3932","impliedFormat":99},{"version":"2fe97c700340d65f35f1bf31a74e2a530d04f47fc2ce7423d4880216452ab085","impliedFormat":99},{"version":"50bc55fc955fa799a4a1a11c3484077f06cc87033c68f5da6466b520876cb12f","impliedFormat":99},{"version":"22973bc5e4a4013061472e4bf3355fb6bb52cc5dfb42406d0aef0357a1fb3735","signature":"5b053d96ccc6391f56b1067a3cfbf5242924a0d3b023d731e16e0590595b24ff"},{"version":"1e11b1a41f7e23f50090b890487660f444092a91c9670a309e51f85f439091c8","signature":"29b81b6565ea28b26b07a2397a01c385b9da74235f1a867a33121354ba494f6f"},{"version":"c0479252952435fc8723ff7c46ed0ee950c4df55120837b27388ec17aaebf48c","signature":"57588e86a3dc1e1d63c6677ea4f3ac4a3529bacb3ba2eac4c4e9db5d174ac500"},{"version":"0b538297db0f7f6d639363e6e05d44e838d6c22b54519b0f794b642dc4c7c8c5","signature":"38b417f10aa857d5069b795c8b22e2952d287d22434596aa41cdec514ef8a073"},{"version":"e2ab89665b8d3a6097916601f56f8d8af1a8491ff63badd7eac3343d74979e0c","signature":"7184a811eca741a0b632eaec8dc054be85644743c22d84c0d76c6ce766a8f003"},{"version":"591b5d40d84be86d4603185460d15b35bb362bae84c46d55b511e54017d4ffe1","signature":"4e6c38cb8996d9c28afbf8c421f736c09b408079582482f3e65a0cba51d70d94"},{"version":"375700e065dd9948ca1ebb6793f62c18890f37bcb42ab757d73df6623dd903d9","impliedFormat":99},{"version":"4781142e27cfd19d75a2c0ee432826153fcdf670bdc52631a6078330c9133e6f","impliedFormat":99},{"version":"93515fa80b2295b33e3e38c3f835f1f602e1a1899b2cfa4215f11600478379c2","impliedFormat":99},{"version":"94896adfc3bcc06c707d9b3e4b3d0001d9ea39cd4ae805082a14491efbed6316","signature":"ee7a7d891dd0b0005b4dc9a7bcdb89e4300038f59ef33866731f1ae221e6f8ee"},{"version":"c0d5f92a6d77a03a29f28f3dde8a8e6d468106a0b28c6d89431120682f1a28a4","signature":"9bf65df0d6132710e4168e290fd206b6f555b1877f94d4ff3075502c6ab4c62c"},{"version":"57aa303c296ff62f609c5a52ec5afbeb02cac7b769cbebb46be7b576e1ab3ddf","signature":"db56e1285f6ec596827631cbe48c095bbea2e8fdc3f901db2b21a51c08e60ce3"},{"version":"c13bc0c7c75bc996a9157a6319e3d007996d1389efc23e1417f0f42a3faf6045","impliedFormat":99},{"version":"f665b7400ea6d37fcc8bf8adb593cbc976926c13a616bc1bd6de8d8edda9f2b8","impliedFormat":99},{"version":"5c1255a52052237b712730bd0da805b0a708262909e500479a321688c1d6d197","impliedFormat":99},{"version":"b5a7c01a7b037ba33207ea7f1cf4c1fe65cfdde4ef83a8e1deb03f777e7ef2e0","signature":"7daf2126a5d8bdf4ef07669a69b291a46b76739e1085849baedcb94ef341e814"},{"version":"aa7a5425ff1fe64b035d4ac9c77ca1faaf410c4de7200be4cd112d53df6c1af9","signature":"9bc80befce6a60cc78a9eff1499995de23613754ca5339d92024a1b10a3ae338"},{"version":"703473df5a12fd91f969f58394059f512dd70d88c2eed68583a77212968094b6","signature":"048ef49f923e7ad7b06ffe95ceb407238a4554bf49dc36eaf1a76eaf75535edb"},{"version":"8309c9db65b1f3ecf337e2d73e26d137ef711d951f2a93643a7bcdcd7a979a19","signature":"658714ef591d2d51abab7172f2dcbddac9cfcd3e7c9ef6ba4f0a85248f6850df"},{"version":"4902f89e2c23ae6814a3818577c8602e2211912c1c74219846dd0d7709f3c328","signature":"5b4567b44b055c85ac88531073f1550a5465ea96dd82620c7b756ac0a8552ed3"},{"version":"9f8f8780b5c9b6978ba85fa25d1c191a001f0f5ff149826f80ec5ad6ae5277ef","signature":"b2c7cf7f304f6ebfea4dda1e9c526a79a591fc8d3bd003af083384025da649b1"},{"version":"163c2623809f0fce501b02fe357fbfdcd7139d1328c10f9be20104ef26a1dcb0","signature":"3c08f6713620a686351d4a0751134e94e3f78f66642b7c22f8afffd2c523b703"},{"version":"e2364b197fec05f73512998a6500bcf9d7c7e67ed1e95426f84b34bffb5609d3","signature":"0a7fd7460c25272fe93528407b12b7e1874a657e9c3a3070d6e37864f095b6a0"},{"version":"cb1149dc9b8b49da93176fad7a5a04f97fd7814b92c00b2608fd06c9142f76af","signature":"ce197bc1ea19e11d3155e4f5868cf5fd6a37fe7ccd32b2bfa434a61c69cb2e00"},{"version":"9df2681521a3c1735b5f226ef0ea22506fad3fe592a0bd5822154b138ae9b4e1","signature":"84383d95b737166ea6ddbc17657294cf019eda14cc8bdb5cef37994d59411e33"},{"version":"d41a68d60235fc1ad32ebf8eb0801bda0dbdf57992963503cfeace5c1f09bac9","signature":"7feccbfe0b4f3bbc1845f7982d68ce418f78481d0551310b84f96b7f9b2054b2"},{"version":"abdf38defffa91a0b8d26bd44033f148339036d56a4d1b8c83bd84cbd9689376","signature":"85580d3804f4284f0c83977fcf42034a794963b26f5ce929a15d84dec78fa1ba"},{"version":"b67e583128915dd73859e4e8f1e0df85f461ba3cc6997fb9b9af2402e4a5f431","signature":"e48edb6bb46fd51d556c424443612274746402c087eb39181775343d8e823618"},{"version":"f3a959e927e7f615371474ae959d900f19f03586a582e4e7dc9d35055cd06ac8","signature":"817ea241dbf951a15227290a558a5f75568c2baa3ab780809dc77e3cc45fda07"},{"version":"cb8f71eb51a21690b5cd207c0624b2e791de4c86617ec4f77edbc43738821211","signature":"b12a354249fdbc0ade9ef40f09af35ac2a6eea05cfc4c0410595379f518bdef4"},{"version":"742246c4523cfe0256bb85e503d55afa7411d5dd0792e8ff69bfdf8afe1cec76","signature":"d4ae819a0e3b5a81e1da7c92cab87f3d0724595e70b05ab6c431d93e08ac6361"},{"version":"57ae71d27ee71b7d1f2c6d867ddafbbfbaa629ad75565e63a508dbaa3ef9f859","impliedFormat":99},{"version":"60924ca0c60f0674f208bfa1eaaa54e6973ced7650df7c7a81ae069730ef665a","impliedFormat":99},{"version":"e3181c7595a89dd03ba9a20eb5065fa37e0b0a514261bed774f6ae2241634470","impliedFormat":99},{"version":"c42d5cbf94816659c01f7c2298d0370247f1a981f8ca6370301b7a03b3ced950","impliedFormat":99},{"version":"18c18ab0341fd5fdfefb5d992c365be1696bfe000c7081c964582b315e33f8f2","impliedFormat":99},{"version":"dafbd4199902d904e3d4a233b5faf5dc4c98847fcd8c0ddd7617b2aed50e90d8","impliedFormat":99},{"version":"9fc866f9783d12d0412ed8d68af5e4c9e44f0072d442b0c33c3bda0a5c8cae15","impliedFormat":99},{"version":"5fc13d24a2d0328eac00c4e73cc052a987fbced2151bc0d3b7eb8f3ba4d0f4e2","impliedFormat":99},{"version":"2cef84bf00cbdb452fdc5d8ecfe7b8c0aa3fa788bdc4ad8961e2e636530dbb60","impliedFormat":99},{"version":"24104650185414f379d5cc35c0e2c19f06684a73de5b472bae79e0d855771ecf","impliedFormat":99},{"version":"799003c0ab928582fca04977f47b8d85b43a8de610f4eef0ad2d069fbb9f9399","impliedFormat":99},{"version":"b13dd41c344a23e085f81b2f5cd96792e6b35ae814f32b25e39d9841844ad240","impliedFormat":99},{"version":"17d8b4e6416e48b6e23b73d05fd2fde407e2af8fddbe9da2a98ede14949c3489","impliedFormat":99},{"version":"6d17b2b41f874ab4369b8e04bdbe660163ea5c8239785c850f767370604959e3","impliedFormat":99},{"version":"04b4c044c8fe6af77b6c196a16c41e0f7d76b285d036d79dcaa6d92e24b4982b","impliedFormat":99},{"version":"30bdeead5293c1ddfaea4097d3e9dd5a6b0bc59a1e07ff4714ea1bbe7c5b2318","impliedFormat":99},{"version":"e7df226dcc1b0ce76b32f160556f3d1550124c894aae2d5f73cefaaf28df7779","impliedFormat":99},{"version":"f2b7eef5c46c61e6e72fba9afd7cc612a08c0c48ed44c3c5518559d8508146a2","impliedFormat":99},{"version":"00f0ba57e829398d10168b7db1e16217f87933e61bd8612b53a894bd7d6371da","impliedFormat":99},{"version":"126b20947d9fa74a88bb4e9281462bda05e529f90e22d08ee9f116a224291e84","impliedFormat":99},{"version":"40d9e43acee39702745eb5c641993978ac40f227475eacc99a83ba893ad995db","impliedFormat":99},{"version":"8a66b69b21c8de9cb88b4b6d12f655d5b7636e692a014c5aa1bd81745c8c51d5","impliedFormat":99},{"version":"ebbb846bdd5a78fdacff59ae04cea7a097912aeb1a2b34f8d88f4ebb84643069","impliedFormat":99},{"version":"7321adb29ffd637acb33ee67ea035f1a97d0aa0b14173291cc2fd58e93296e04","impliedFormat":99},{"version":"320816f1a4211188f07a782bdb6c1a44555b3e716ce13018f528ad7387108d5f","impliedFormat":99},{"version":"b2cc8a474b7657f4a03c67baf6bff75e26635fd4b5850675e8cad524a09ddd0c","impliedFormat":99},{"version":"0d081e9dc251063cc69611041c17d25847e8bdbe18164baaa89b7f1f1633c0ab","impliedFormat":99},{"version":"a64c25d8f4ec16339db49867ea2324e77060782993432a875d6e5e8608b0de1e","impliedFormat":99},{"version":"0739310b6b777f3e2baaf908c0fbc622c71160e6310eb93e0d820d86a52e2e23","impliedFormat":99},{"version":"37b32e4eadd8cd3c263e7ac1681c58b2ac54f3f77bb34c5e4326cc78516d55a9","impliedFormat":99},{"version":"9b7a8974e028c4ed6f7f9abb969e3eb224c069fd7f226e26fcc3a5b0e2a1eba8","impliedFormat":99},{"version":"e8100b569926a5592146ed68a0418109d625a045a94ed878a8c5152b1379237c","impliedFormat":99},{"version":"594201c616c318b7f3149a912abd8d6bdf338d765b7bcbde86bca2e66b144606","impliedFormat":99},{"version":"03e380975e047c5c6ded532cf8589e6cc85abb7be3629e1e4b0c9e703f2fd36f","impliedFormat":99},{"version":"fae14b53b7f52a8eb3274c67c11f261a58530969885599efe3df0277b48909e1","impliedFormat":99},{"version":"c41206757c428186f2e0d1fd373915c823504c249336bdc9a9c9bbdf9da95fef","impliedFormat":99},{"version":"e961f853b7b0111c42b763a6aa46fc70d06a697db3d8ed69b38f7ba0ae42a62b","impliedFormat":99},{"version":"3db90f79e36bcb60b3f8de1bc60321026800979c150e5615047d598c787a64b7","impliedFormat":99},{"version":"639b6fb3afbb8f6067c1564af2bd284c3e883f0f1556d59bd5eb87cdbbdd8486","impliedFormat":99},{"version":"49795f5478cb607fd5965aa337135a8e7fd1c58bc40c0b6db726adf186dd403f","impliedFormat":99},{"version":"7d8890e6e2e4e215959e71d5b5bd49482cf7a23be68d48ea446601a4c99bd511","impliedFormat":99},{"version":"d56f72c4bb518de5702b8b6ae3d3c3045c99e0fd48b3d3b54c653693a8378017","impliedFormat":99},{"version":"4c9ac40163e4265b5750510d6d2933fb7b39023eed69f7b7c68b540ad960826e","impliedFormat":99},{"version":"8dfab17cf48e7be6e023c438a9cdf6d15a9b4d2fa976c26e223ba40c53eb8da8","impliedFormat":99},{"version":"38bdf7ccacfd8e418de3a7b1e3cecc29b5625f90abc2fa4ac7843a290f3bf555","impliedFormat":99},{"version":"9819e46a914735211fbc04b8dc6ba65152c62e3a329ca0601a46ba6e05b2c897","impliedFormat":99},{"version":"50f0dc9a42931fb5d65cdd64ba0f7b378aedd36e0cfca988aa4109aad5e714cb","impliedFormat":99},{"version":"894f23066f9fafccc6e2dd006ed5bd85f3b913de90f17cf1fe15a2eb677fd603","impliedFormat":99},{"version":"abdf39173867e6c2d6045f120a316de451bbb6351a6929546b8470ddf2e4b3b9","impliedFormat":99},{"version":"aa2cb4053f948fbd606228195bbe44d78733861b6f7204558bbee603202ee440","impliedFormat":99},{"version":"6911b41bfe9942ac59c2da1bbcbe5c3c1f4e510bf65cae89ed00f434cc588860","impliedFormat":99},{"version":"7b81bc4d4e2c764e85d869a8dd9fe3652b34b45c065482ac94ffaacc642b2507","impliedFormat":99},{"version":"895df4edb46ccdcbce2ec982f5eed292cf7ea3f7168f1efea738ee346feab273","impliedFormat":99},{"version":"8692bb1a4799eda7b2e3288a6646519d4cebb9a0bddf800085fc1bd8076997a0","impliedFormat":99},{"version":"239c9e98547fe99711b01a0293f8a1a776fc10330094aa261f3970aaba957c82","impliedFormat":99},{"version":"34833ec50360a32efdc12780ae624e9a710dd1fd7013b58c540abf856b54285a","impliedFormat":99},{"version":"647538e4007dcc351a8882067310a0835b5bb8559d1cfa5f378e929bceb2e64d","impliedFormat":99},{"version":"992d6b1abcc9b6092e5a574d51d441238566b6461ade5de53cb9718e4f27da46","impliedFormat":99},{"version":"938702305649bf1050bd79f3803cf5cc2904596fc1edd4e3b91033184eae5c54","impliedFormat":99},{"version":"1e931d3c367d4b96fe043e792196d9c2cf74f672ff9c0b894be54e000280a79d","impliedFormat":99},{"version":"05bec322ea9f6eb9efcd6458bb47087e55bd688afdd232b78379eb5d526816ed","impliedFormat":99},{"version":"4c449a874c2d2e5e5bc508e6aa98f3140218e78c585597a21a508a647acd780a","impliedFormat":99},{"version":"dae15e326140a633d7693e92b1af63274f7295ea94fb7c322d5cbe3f5e48be88","impliedFormat":99},{"version":"c2b0a869713bca307e58d81d1d1f4b99ebfc7ec8b8f17e80dde40739aa8a2bc6","impliedFormat":99},{"version":"6e4b4ff6c7c54fa9c6022e88f2f3e675eac3c6923143eb8b9139150f09074049","impliedFormat":99},{"version":"69559172a9a97bbe34a32bff8c24ef1d8c8063feb5f16a6d3407833b7ee504cf","impliedFormat":99},{"version":"86b94a2a3edcb78d9bfcdb3b382547d47cb017e71abe770c9ee8721e9c84857f","impliedFormat":99},{"version":"e3fafafda82853c45c0afc075fea1eaf0df373a06daf6e6c7f382f9f61b2deb3","impliedFormat":99},{"version":"a4ba4b31de9e9140bc49c0addddbfaf96b943a7956a46d45f894822e12bf5560","impliedFormat":99},{"version":"d8a7926fc75f2ed887f17bae732ee31a4064b8a95a406c87e430c58578ee1f67","impliedFormat":99},{"version":"9886ffbb134b0a0059fd82219eba2a75f8af341d98bc6331b6ef8a921e10ec68","impliedFormat":99},{"version":"c2ead057b70d0ae7b87a771461a6222ebdb187ba6f300c974768b0ae5966d10e","impliedFormat":99},{"version":"46687d985aed8485ab2c71085f82fafb11e69e82e8552cf5d3849c00e64a00a5","impliedFormat":99},{"version":"999ca66d4b5e2790b656e0a7ce42267737577fc7a52b891e97644ec418eff7ec","impliedFormat":99},{"version":"ec948ee7e92d0888f92d4a490fdd0afb27fbf6d7aabebe2347a3e8ac82c36db9","impliedFormat":99},{"version":"03ef2386c683707ce741a1c30cb126e8c51a908aa0acc01c3471fafb9baaacd5","impliedFormat":99},{"version":"66a372e03c41d2d5e920df5282dadcec2acae4c629cb51cab850825d2a144cea","impliedFormat":99},{"version":"ddf9b157bd4c06c2e4646c9f034f36267a0fbd028bd4738214709de7ea7c548b","impliedFormat":99},{"version":"3e795aac9be23d4ad9781c00b153e7603be580602e40e5228e2dafe8a8e3aba1","impliedFormat":99},{"version":"98c461ec5953dfb1b5d5bca5fee0833c8a932383b9e651ca6548e55f1e2c71c3","impliedFormat":99},{"version":"5c42107b46cb1d36b6f1dee268df125e930b81f9b47b5fa0b7a5f2a42d556c10","impliedFormat":99},{"version":"7e32f1251d1e986e9dd98b6ff25f62c06445301b94aeebdf1f4296dbd2b8652f","impliedFormat":99},{"version":"2f7e328dda700dcb2b72db0f58c652ae926913de27391bd11505fc5e9aae6c33","impliedFormat":99},{"version":"3de7190e4d37da0c316db53a8a60096dbcd06d1a50677ccf11d182fa26882080","impliedFormat":99},{"version":"a9d6f87e59b32b02c861aade3f4477d7277c30d43939462b93f48644fa548c58","impliedFormat":99},{"version":"2bce8fd2d16a9432110bbe0ba1e663fd02f7d8b8968cd10178ea7bc306c4a5df","impliedFormat":99},{"version":"798bedbf45a8f1e55594e6879cd46023e8767757ecce1d3feaa78d16ad728703","impliedFormat":99},{"version":"62723d5ac66f7ed6885a3931dd5cfa017797e73000d590492988a944832e8bc2","impliedFormat":99},{"version":"03db8e7df7514bf17fc729c87fff56ca99567b9aa50821f544587a666537c233","impliedFormat":99},{"version":"9b1f311ba4409968b68bf20b5d892dbd3c5b1d65c673d5841c7dbde351bc0d0b","impliedFormat":99},{"version":"2d1e8b5431502739fe335ceec0aaded030b0f918e758a5d76f61effa0965b189","impliedFormat":99},{"version":"e725839b8f884dab141b42e9d7ff5659212f6e1d7b4054caa23bc719a4629071","impliedFormat":99},{"version":"4fa38a0b8ae02507f966675d0a7d230ed67c92ab8b5736d99a16c5fbe2b42036","impliedFormat":99},{"version":"50ec1e8c23bad160ddedf8debeebc722becbddda127b8fdce06c23eacd3fe689","impliedFormat":99},{"version":"9a0aea3a113064fd607f41375ade308c035911d3c8af5ae9db89593b5ca9f1f9","impliedFormat":99},{"version":"8d643903b58a0bf739ce4e6a8b0e5fb3fbdfaacbae50581b90803934b27d5b89","impliedFormat":99},{"version":"19de2915ccebc0a1482c2337b34cb178d446def2493bf775c4018a4ea355adb8","impliedFormat":99},{"version":"9be8fc03c8b5392cd17d40fd61063d73f08d0ee3457ecf075dcb3768ae1427bd","impliedFormat":99},{"version":"a2d89a8dc5a993514ca79585039eea083a56822b1d9b9d9d85b14232e4782cbe","impliedFormat":99},{"version":"f526f20cae73f17e8f38905de4c3765287575c9c4d9ecacee41cfda8c887da5b","impliedFormat":99},{"version":"d9ec0978b7023612b9b83a71fee8972e290d02f8ff894e95cdd732cd0213b070","impliedFormat":99},{"version":"7ab10c473a058ec8ac4790b05cae6f3a86c56be9b0c0a897771d428a2a48a9f9","impliedFormat":99},{"version":"451d7a93f8249d2e1453b495b13805e58f47784ef2131061821b0e456a9fd0e1","impliedFormat":99},{"version":"21c56fe515d227ed4943f275a8b242d884046001722a4ba81f342a08dbe74ae2","impliedFormat":99},{"version":"d8311f0c39381aa1825081c921efde36e618c5cf46258c351633342a11601208","impliedFormat":99},{"version":"6b50c3bcc92dc417047740810596fcb2df2502aa3f280c9e7827e87896da168a","impliedFormat":99},{"version":"18a6b318d1e7b31e5749a52be0cf9bbce1b275f63190ef32e2c79db0579328ca","impliedFormat":99},{"version":"6a2d0af2c27b993aa85414f3759898502aa198301bc58b0d410948fe908b07b0","impliedFormat":99},{"version":"2da11b6f5c374300e5e66a6b01c3c78ec21b5d3fec0748a28cc28e00be73e006","impliedFormat":99},{"version":"0729691b39c24d222f0b854776b00530877217bfc30aac1dc7fa2f4b1795c536","impliedFormat":99},{"version":"ca45bb5c98c474d669f0e47615e4a5ae65d90a2e78531fda7862ee43e687a059","impliedFormat":99},{"version":"c1c058b91d5b9a24c95a51aea814b0ad4185f411c38ac1d5eef0bf3cebec17dc","impliedFormat":99},{"version":"3ab0ed4060b8e5b5e594138aab3e7f0262d68ad671d6678bcda51568d4fc4ccc","impliedFormat":99},{"version":"e2bf1faba4ff10a6020c41df276411f641d3fdce5c6bae1db0ec84a0bf042106","impliedFormat":99},{"version":"80b0a8fe14d47a71e23d7c3d4dcee9584d4282ef1d843b70cab1a42a4ea1588c","impliedFormat":99},{"version":"a0f02a73f6e3de48168d14abe33bf5970fdacdb52d7c574e908e75ad571e78f7","impliedFormat":99},{"version":"c728002a759d8ec6bccb10eed56184e86aeff0a762c1555b62b5d0fa9d1f7d64","impliedFormat":99},{"version":"586f94e07a295f3d02f847f9e0e47dbf14c16e04ccc172b011b3f4774a28aaea","impliedFormat":99},{"version":"cfe1a0f4ed2df36a2c65ea6bc235dbb8cf6e6c25feb6629989f1fa51210b32e7","impliedFormat":99},{"version":"8ba69c9bf6de79c177329451ffde48ddab7ec495410b86972ded226552f664df","impliedFormat":99},{"version":"15111cbe020f8802ad1d150524f974a5251f53d2fe10eb55675f9df1e82dbb62","impliedFormat":99},{"version":"782dc153c56a99c9ed07b2f6f497d8ad2747764966876dbfef32f3e27ce11421","impliedFormat":99},{"version":"cc2db30c3d8bb7feb53a9c9ff9b0b859dd5e04c83d678680930b5594b2bf99cb","impliedFormat":99},{"version":"46909b8c85a6fd52e0807d18045da0991e3bdc7373435794a6ba425bc23cc6be","impliedFormat":99},{"version":"e4e511ff63bb6bd69a2a51e472c6044298bca2c27835a34a20827bc3ef9b7d13","impliedFormat":99},{"version":"2c86f279d7db3c024de0f21cd9c8c2c972972f842357016bfbbd86955723b223","impliedFormat":99},{"version":"112c895cff9554cf754f928477c7d58a21191c8089bffbf6905c87fe2dc6054f","impliedFormat":99},{"version":"8cfc293b33082003cacbf7856b8b5e2d6dd3bde46abbd575b0c935dc83af4844","impliedFormat":99},{"version":"d2c5c53f85ce0474b3a876d76c4fc44ff7bb766b14ed1bf495f9abac181d7f5f","impliedFormat":99},{"version":"3c523f27926905fcbe20b8301a0cc2da317f3f9aea2273f8fc8d9ae88b524819","impliedFormat":99},{"version":"9ca0d706f6b039cc52552323aeccb4db72e600b67ddc7a54cebc095fc6f35539","impliedFormat":99},{"version":"a64909a9f75081342ddd061f8c6b49decf0d28051bc78e698d347bdcb9746577","impliedFormat":99},{"version":"7d8d55ae58766d0d52033eae73084c4db6a93c4630a3e17f419dd8a0b2a4dcd8","impliedFormat":99},{"version":"b8b5c8ba972d9ffff313b3c8a3321e7c14523fc58173862187e8d1cb814168ac","impliedFormat":99},{"version":"9c42c0fa76ee36cf9cc7cc34b1389fbb4bd49033ec124b93674ec635fabf7ffe","impliedFormat":99},{"version":"6184c8da9d8107e3e67c0b99dedb5d2dfe5ccf6dfea55c2a71d4037caf8ca196","impliedFormat":99},{"version":"4030ceea7bf41449c1b86478b786e3b7eadd13dfe5a4f8f5fe2eb359260e08b3","impliedFormat":99},{"version":"7bf516ec5dfc60e97a5bde32a6b73d772bd9de24a2e0ec91d83138d39ac83d04","impliedFormat":99},{"version":"e6a6fb3e6525f84edf42ba92e261240d4efead3093aca3d6eb1799d5942ba393","impliedFormat":99},{"version":"45df74648934f97d26800262e9b2af2f77ef7191d4a5c2eb1df0062f55e77891","impliedFormat":99},{"version":"3fe361e4e567f32a53af1f2c67ad62d958e3d264e974b0a8763d174102fe3b29","impliedFormat":99},{"version":"28b520acee4bc6911bfe458d1ad3ebc455fa23678463f59946ad97a327c9ab2b","impliedFormat":99},{"version":"121b39b1a9ad5d23ed1076b0db2fe326025150ef476dccb8bf87778fcc4f6dd7","impliedFormat":99},{"version":"f791f92a060b52aa043dde44eb60307938f18d4c7ac13df1b52c82a1e658953f","impliedFormat":99},{"version":"df09443e7743fd6adc7eb108e760084bacdf5914403b7aac5fbd4dc4e24e0c2c","impliedFormat":99},{"version":"eeb4ff4aa06956083eaa2aad59070361c20254b865d986bc997ee345dbd44cbb","impliedFormat":99},{"version":"ed84d5043444d51e1e5908f664addc4472c227b9da8401f13daa565f23624b6e","impliedFormat":99},{"version":"146bf888b703d8baa825f3f2fb1b7b31bda5dff803e15973d9636cdda33f4af3","impliedFormat":99},{"version":"b4ec8b7a8d23bdf7e1c31e43e5beac3209deb7571d2ccf2a9572865bf242da7c","impliedFormat":99},{"version":"3fba0d61d172091638e56fba651aa1f8a8500aac02147d29bd5a9cc0bc8f9ec2","impliedFormat":99},{"version":"a5a57deb0351b03041e0a1448d3a0cc5558c48e0ed9b79b69c99163cdca64ad8","impliedFormat":99},{"version":"9bcecf0cbc2bfc17e33199864c19549905309a0f9ecc37871146107aac6e05ae","impliedFormat":99},{"version":"d6a211db4b4a821e93c978add57e484f2a003142a6aef9dbfa1fe990c66f337b","impliedFormat":99},{"version":"bd4d10bd44ce3f630dd9ce44f102422cb2814ead5711955aa537a52c8d2cae14","impliedFormat":99},{"version":"08e4c39ab1e52eea1e528ee597170480405716bae92ebe7a7c529f490afff1e0","impliedFormat":99},{"version":"625bb2bc3867557ea7912bd4581288a9fca4f3423b8dffa1d9ed57fafc8610e3","impliedFormat":99},{"version":"d1992164ecc334257e0bef56b1fd7e3e1cea649c70c64ffc39999bb480c0ecdf","impliedFormat":99},{"version":"a53ff2c4037481eb357e33b85e0d78e8236e285b6428b93aa286ceea1db2f5dc","impliedFormat":99},{"version":"4fe608d524954b6857d78857efce623852fcb0c155f010710656f9db86e973a5","impliedFormat":99},{"version":"b53b62a9838d3f57b70cc456093662302abb9962e5555f5def046172a4fe0d4e","impliedFormat":99},{"version":"9866369eb72b6e77be2a92589c9df9be1232a1a66e96736170819e8a1297b61f","impliedFormat":99},{"version":"43abfbdf4e297868d780b8f4cfdd8b781b90ecd9f588b05e845192146a86df34","impliedFormat":99},{"version":"582419791241fb851403ae4a08d0712a63d4c94787524a7419c2bc8e0eb1b031","impliedFormat":99},{"version":"18437eeb932fe48590b15f404090db0ab3b32d58f831d5ffc157f63b04885ee5","impliedFormat":99},{"version":"0c5eaedf622d7a8150f5c2ec1f79ac3d51eea1966b0b3e61bfdea35e8ca213a7","impliedFormat":99},{"version":"fac39fc7a9367c0246de3543a6ee866a0cf2e4c3a8f64641461c9f2dac0d8aae","impliedFormat":99},{"version":"3b9f559d0200134f3c196168630997caedeadc6733523c8b6076a09615d5dec8","impliedFormat":99},{"version":"932af64286d9723da5ef7b77a0c4229829ce8e085e6bcc5f874cb0b83e8310d4","impliedFormat":99},{"version":"adeb9278f11f5561157feee565171c72fd48f5fe34ed06f71abf24e561fcaa1e","impliedFormat":99},{"version":"2269fef79b4900fc6b08c840260622ca33524771ff24fda5b9101ad98ea551f3","impliedFormat":99},{"version":"73d47498a1b73d5392d40fb42a3e7b009ae900c8423f4088c4faa663cc508886","impliedFormat":99},{"version":"7efc34cdc4da0968c3ba687bc780d5cacde561915577d8d1c1e46c7ac931d023","impliedFormat":99},{"version":"3c20a3bb0c50c819419f44aa55acc58476dad4754a16884cef06012d02b0722f","impliedFormat":99},{"version":"4569abf6bc7d51a455503670f3f1c0e9b4f8632a3b030e0794c61bfbba2d13be","impliedFormat":99},{"version":"98b2297b4dc1404078a54b61758d8643e4c1d7830af724f3ed2445d77a7a2d57","impliedFormat":99},{"version":"952ba89d75f1b589e07070fea2d8174332e3028752e76fd46e1c16cc51e6e2af","impliedFormat":99},{"version":"b6c9a2deefb6a57ff68d2a38d33c34407b9939487fc9ee9f32ba3ecf2987a88a","impliedFormat":99},{"version":"f6b371377bab3018dac2bca63e27502ecbd5d06f708ad7e312658d3b5315d948","impliedFormat":99},{"version":"31947dd8f1c8eeb7841e1f139a493a73bd520f90e59a6415375d0d8e6a031f01","impliedFormat":99},{"version":"95cd83b807e10b1af408e62caf5fea98562221e8ddca9d7ccc053d482283ddda","impliedFormat":99},{"version":"19287d6b76288c2814f1633bdd68d2b76748757ffd355e73e41151644e4773d6","impliedFormat":99},{"version":"fc4e6ec7dade5f9d422b153c5d8f6ad074bd9cc4e280415b7dc58fb5c52b5df1","impliedFormat":99},{"version":"3aea973106e1184db82d8880f0ca134388b6cbc420f7309d1c8947b842886349","impliedFormat":99},{"version":"765e278c464923da94dda7c2b281ece92f58981642421ae097862effe2bd30fa","impliedFormat":99},{"version":"de260bed7f7d25593f59e859bd7c7f8c6e6bb87e8686a0fcafa3774cb5ca02d8","impliedFormat":99},{"version":"b5c341ce978f5777fbe05bc86f65e9906a492fa6b327bda3c6aae900c22e76c6","impliedFormat":99},{"version":"686ddbfaf88f06b02c6324005042f85317187866ca0f8f4c9584dd9479653344","impliedFormat":99},{"version":"7f789c0c1db29dd3aab6e159d1ba82894a046bf8df595ac48385931ae6ad83e0","impliedFormat":99},{"version":"8eb3057d4fe9b59b2492921b73a795a2455ebe94ccb3d01027a7866612ead137","impliedFormat":99},{"version":"1e43c5d7aee1c5ec20611e28b5417f5840c75d048de9d7f1800d6808499236f8","impliedFormat":99},{"version":"d42610a5a2bee4b71769968a24878885c9910cd049569daa2d2ee94208b3a7a5","impliedFormat":99},{"version":"f6ed95506a6ed2d40ed5425747529befaa4c35fcbbc1e0d793813f6d725690fa","impliedFormat":99},{"version":"a6fcc1cd6583939506c906dff1276e7ebdc38fbe12d3e108ba38ad231bd18d97","impliedFormat":99},{"version":"ed13354f0d96fb6d5878655b1fead51722b54875e91d5e53ef16de5b71a0e278","impliedFormat":99},{"version":"1193b4872c1fb65769d8b164ca48124c7ebacc33eae03abf52087c2b29e8c46c","impliedFormat":99},{"version":"af682dfabe85688289b420d939020a10eb61f0120e393d53c127f1968b3e9f66","impliedFormat":99},{"version":"0dca04006bf13f72240c6a6a502df9c0b49c41c3cab2be75e81e9b592dcd4ea8","impliedFormat":99},{"version":"79d6ac4a2a229047259116688f9cd62fda25422dee3ad304f77d7e9af53a41ef","impliedFormat":99},{"version":"64534c17173990dc4c3d9388d16675a059aac407031cfce8f7fdffa4ee2de988","impliedFormat":99},{"version":"ba46d160a192639f3ca9e5b640b870b1263f24ac77b6895ab42960937b42dcbb","impliedFormat":99},{"version":"5e5ddd6fc5b590190dde881974ab969455e7fad61012e32423415ae3d085b037","impliedFormat":99},{"version":"1c16fd00c42b60b96fe0fa62113a953af58ddf0d93b0a49cb4919cf5644616f0","impliedFormat":99},{"version":"eb240c0e6b412c57f7d9a9f1c6cd933642a929837c807b179a818f6e8d3a4e44","impliedFormat":99},{"version":"4a7bde5a1155107fc7d9483b8830099f1a6072b6afda5b78d91eb5d6549b3956","impliedFormat":99},{"version":"3c1baaffa9a24cc7ef9eea6b64742394498e0616b127ca630aca0e11e3298006","impliedFormat":99},{"version":"87ca1c31a326c898fa3feb99ec10750d775e1c84dbb7c4b37252bcf3742c7b21","impliedFormat":99},{"version":"d7bd26af1f5457f037225602035c2d7e876b80d02663ab4ca644099ad3a55888","impliedFormat":99},{"version":"2ad0a6b93e84a56b64f92f36a07de7ebcb910822f9a72ad22df5f5d642aff6f3","impliedFormat":99},{"version":"523d1775135260f53f672264937ee0f3dc42a92a39de8bee6c48c7ea60b50b5a","impliedFormat":99},{"version":"e441b9eebbc1284e5d995d99b53ed520b76a87cab512286651c4612d86cd408e","impliedFormat":99},{"version":"76f853ee21425c339a79d28e0859d74f2e53dee2e4919edafff6883dd7b7a80f","impliedFormat":99},{"version":"00cf042cd6ba1915648c8d6d2aa00e63bbbc300ea54d28ed087185f0f662e080","impliedFormat":99},{"version":"f57e6707d035ab89a03797d34faef37deefd3dd90aa17d90de2f33dce46a2c56","impliedFormat":99},{"version":"cc8b559b2cf9380ca72922c64576a43f000275c72042b2af2415ce0fb88d7077","impliedFormat":99},{"version":"1a337ca294c428ba8f2eb01e887b28d080ee4a4307ae87e02e468b1d26af4a74","impliedFormat":99},{"version":"5a15362fc2e72765a908c0d4dd89e3ab3b763e8bc8c23f19234a709ecfd202fe","impliedFormat":99},{"version":"2dffdfe62ac8af0943853234519616db6fd8958fc7ff631149fd8364e663f361","impliedFormat":99},{"version":"5dbdb2b2229b5547d8177c34705272da5a10b8d0033c49efbc9f6efba5e617f2","impliedFormat":99},{"version":"6fc0498cd8823d139004baff830343c9a0d210c687b2402c1384fb40f0aa461c","impliedFormat":99},{"version":"8492306a4864a1dc6fc7e0cc0de0ae9279cbd37f3aae3e9dc1065afcdc83dddc","impliedFormat":99},{"version":"c011b378127497d6337a93f020a05f726db2c30d55dc56d20e6a5090f05919a6","impliedFormat":99},{"version":"f4556979e95a274687ae206bbab2bb9a71c3ad923b92df241d9ab88c184b3f40","impliedFormat":99},{"version":"50e82bb6e238db008b5beba16d733b77e8b2a933c9152d1019cf8096845171a4","impliedFormat":99},{"version":"d6011f8b8bbf5163ef1e73588e64a53e8bf1f13533c375ec53e631aad95f1375","impliedFormat":99},{"version":"693cd7936ac7acfa026d4bcb5801fce71cec49835ba45c67af1ef90dbfd30af7","impliedFormat":99},{"version":"195e2cf684ecddfc1f6420564535d7c469f9611ce7a380d6e191811f84556cd2","impliedFormat":99},{"version":"1dc6b6e7b2a7f2962f31c77f4713f3a5a132bbe14c00db75d557568fe82e4311","impliedFormat":99},{"version":"add93b1180e9aaac2dae4ef3b16f7655893e2ecbe62bd9e48366c305f0063d89","impliedFormat":99},{"version":"594bd896fe37c970aafb7a376ebeec4c0d636b62a5f611e2e27d30fb839ad8a5","impliedFormat":99},{"version":"b1c6a6faf60542ba4b4271db045d7faea56e143b326ef507d2797815250f3afc","impliedFormat":99},{"version":"8c8b165beb794260f462679329b131419e9f5f35212de11c4d53e6d4d9cbedf6","impliedFormat":99},{"version":"ee5a4cf57d49fcf977249ab73c690a59995997c4672bb73fcaaf2eed65dbd1b2","impliedFormat":99},{"version":"f9f36051f138ab1c40b76b230c2a12b3ce6e1271179f4508da06a959f8bee4c1","impliedFormat":99},{"version":"9dc2011a3573d271a45c12656326530c0930f92539accbec3531d65131a14a14","impliedFormat":99},{"version":"091521ce3ede6747f784ae6f68ad2ea86bbda76b59d2bf678bcad2f9d141f629","impliedFormat":99},{"version":"202c2be951f53bafe943fb2c8d1245e35ed0e4dfed89f48c9a948e4d186dd6d4","impliedFormat":99},{"version":"c618aead1d799dbf4f5b28df5a6b9ce13d72722000a0ec3fe90a8115b1ea9226","impliedFormat":99},{"version":"9b0bf59708549c3e77fddd36530b95b55419414f88bbe5893f7bc8b534617973","impliedFormat":99},{"version":"7e216f67c4886f1bde564fb4eebdd6b185f262fe85ad1d6128cad9b229b10354","impliedFormat":99},{"version":"cd51e60b96b4d43698df74a665aa7a16604488193de86aa60ec0c44d9f114951","impliedFormat":99},{"version":"b63341fb6c7ba6f2aeabd9fc46b43e6cc2d2b9eec06534cfd583d9709f310ec2","impliedFormat":99},{"version":"be2af50c81b15bcfe54ad60f53eb1c72dae681c72d0a9dce1967825e1b5830a3","impliedFormat":99},{"version":"be5366845dfb9726f05005331b9b9645f237f1ddc594c0def851208e8b7d297b","impliedFormat":99},{"version":"5ddd536aaeadd4bf0f020492b3788ed209a7050ce27abec4e01c7563ff65da81","impliedFormat":99},{"version":"e243b24da119c1ef0d79af2a45217e50682b139cb48e7607efd66cc01bd9dcda","impliedFormat":99},{"version":"5b1398c8257fd180d0bf62e999fe0a89751c641e87089a83b24392efda720476","impliedFormat":99},{"version":"1588b1359f8507a16dbef67cd2759965fc2e8d305e5b3eb71be5aa9506277dff","impliedFormat":99},{"version":"4c99f2524eee1ec81356e2b4f67047a4b7efaf145f1c4eb530cd358c36784423","impliedFormat":99},{"version":"b30c6b9f6f30c35d6ef84daed1c3781e367f4360171b90598c02468b0db2fc3d","impliedFormat":99},{"version":"79c0d32274ccfd45fae74ac61d17a2be27aea74c70806d22c43fc625b7e9f12a","impliedFormat":99},{"version":"1b7e3958f668063c9d24ac75279f3e610755b0f49b1c02bb3b1c232deb958f54","impliedFormat":99},{"version":"779d4022c3d0a4df070f94858a33d9ebf54af3664754536c4ce9fd37c6f4a8db","impliedFormat":99},{"version":"e662f063d46aa8c088edffdf1d96cb13d9a2cbf06bc38dc6fc62b4d125fb7b49","impliedFormat":99},{"version":"d1d612df1e41c90d9678b07740d13d4f8e6acec2f17390d4ff4be5c889a6d37d","impliedFormat":99},{"version":"c95933fe140918892d569186f17b70ef6b1162f851a0f13f6a89e8f4d599c5a1","impliedFormat":99},{"version":"1d8d30677f87c13c2786980a80750ac1e281bdb65aa013ea193766fe9f0edd74","impliedFormat":99},{"version":"4661673cbc984b8a6ee5e14875a71ed529b64e7f8e347e12c0db4cecc25ad67d","impliedFormat":99},{"version":"7f980a414274f0f23658baa9a16e21d828535f9eac538e2eab2bb965325841db","impliedFormat":99},{"version":"20fb747a339d3c1d4a032a31881d0c65695f8167575e01f222df98791a65da9b","impliedFormat":99},{"version":"dd4e7ebd3f205a11becf1157422f98db675a626243d2fbd123b8b93efe5fb505","impliedFormat":99},{"version":"43ec6b74c8d31e88bb6947bb256ad78e5c6c435cbbbad991c3ff39315b1a3dba","impliedFormat":99},{"version":"b27242dd3af2a5548d0c7231db7da63d6373636d6c4e72d9b616adaa2acef7e1","impliedFormat":99},{"version":"e0ee7ba0571b83c53a3d6ec761cf391e7128d8f8f590f8832c28661b73c21b68","impliedFormat":99},{"version":"072bfd97fc61c894ef260723f43a416d49ebd8b703696f647c8322671c598873","impliedFormat":99},{"version":"e70875232f5d5528f1650dd6f5c94a5bed344ecf04bdbb998f7f78a3c1317d02","impliedFormat":99},{"version":"8e495129cb6cd8008de6f4ff8ce34fe1302a9e0dcff8d13714bd5593be3f7898","impliedFormat":99},{"version":"0345bc0b1067588c4ea4c48e34425d3284498c629bc6788ebc481c59949c9037","impliedFormat":99},{"version":"e30f5b5d77c891bc16bd65a2e46cd5384ea57ab3d216c377f482f535db48fc8f","impliedFormat":99},{"version":"f113afe92ee919df8fc29bca91cab6b2ffbdd12e4ac441d2bb56121eb5e7dbe3","impliedFormat":99},{"version":"49d567cc002efb337f437675717c04f207033f7067825b42bb59c9c269313d83","impliedFormat":99},{"version":"1d248f707d02dc76555298a934fba0f337f5028bb1163ce59cd7afb831c9070f","impliedFormat":99},{"version":"5d8debffc9e7b842dc0f17b111673fe0fc0cca65e67655a2b543db2150743385","impliedFormat":99},{"version":"5fccbedc3eb3b23bc6a3a1e44ceb110a1f1a70fa8e76941dce3ae25752caa7a9","impliedFormat":99},{"version":"f4031b95f3bab2b40e1616bd973880fb2f1a97c730bac5491d28d6484fac9560","impliedFormat":99},{"version":"dbe75b3c5ed547812656e7945628f023c4cd0bc1879db0db3f43a57fb8ec0e2b","impliedFormat":99},{"version":"b754718a546a1939399a6d2a99f9022d8a515f2db646bab09f7d2b5bff3cbb82","impliedFormat":99},{"version":"2eef10fb18ed0b4be450accf7a6d5bcce7b7f98e02cac4e6e793b7ad04fc0d79","impliedFormat":99},{"version":"c46f471e172c3be12c0d85d24876fedcc0c334b0dab48060cdb1f0f605f09fed","impliedFormat":99},{"version":"7d6ddeead1d208588586c58c26e4a23f0a826b7a143fb93de62ed094d0056a33","impliedFormat":99},{"version":"7c5782291ff6e7f2a3593295681b9a411c126e3736b83b37848032834832e6b9","impliedFormat":99},{"version":"3a3f09df6258a657dd909d06d4067ee360cd2dccc5f5d41533ae397944a11828","impliedFormat":99},{"version":"ea54615be964503fec7bce04336111a6fa455d3e8d93d44da37b02c863b93eb8","impliedFormat":99},{"version":"2a83694bc3541791b64b0e57766228ea23d92834df5bf0b0fcb93c5bb418069c","impliedFormat":99},{"version":"b5913641d6830e7de0c02366c08b1d26063b5758132d8464c938e78a45355979","impliedFormat":99},{"version":"46c095d39c1887979d9494a824eda7857ec13fb5c20a6d4f7d02c2975309bf45","impliedFormat":99},{"version":"f6e02ca076dc8e624aa38038e3488ebd0091e2faea419082ed764187ba8a6500","impliedFormat":99},{"version":"4d49e8a78aba1d4e0ad32289bf8727ae53bc2def9285dff56151a91e7d770c3e","impliedFormat":99},{"version":"63315cf08117cc728eab8f3eec8801a91d2cd86f91d0ae895d7fd928ab54596d","impliedFormat":99},{"version":"a14a6f3a5636bcaebfe9ec2ccfa9b07dc94deb1f6c30358e9d8ea800a1190d5e","impliedFormat":99},{"version":"21206e7e81876dabf2a7af7aa403f343af1c205bdcf7eff24d9d7f4eee6214c4","impliedFormat":99},{"version":"cd0a9f0ffec2486cad86b7ef1e4da42953ffeb0eb9f79f536e16ff933ec28698","impliedFormat":99},{"version":"f609a6ec6f1ab04dba769e14d6b55411262fd4627a099e333aa8876ea125b822","impliedFormat":99},{"version":"6d8052bb814be030c64cb22ca0e041fe036ad3fc8d66208170f4e90d0167d354","impliedFormat":99},{"version":"851f72a5d3e8a2bf7eeb84a3544da82628f74515c92bdf23c4a40af26dcc1d16","impliedFormat":99},{"version":"59692a7938aab65ea812a8339bbc63c160d64097fe5a457906ea734d6f36bcd4","impliedFormat":99},{"version":"8cb3b95e610c44a9986a7eab94d7b8f8462e5de457d5d10a0b9c6dd16bde563b","impliedFormat":99},{"version":"f571713abd9a676da6237fe1e624d2c6b88c0ca271c9f1acc1b4d8efeea60b66","impliedFormat":99},{"version":"16c5d3637d1517a3d17ed5ebcfbb0524f8a9997a7b60f6100f7c5309b3bb5ac8","impliedFormat":99},{"version":"ca1ec669726352c8e9d897f24899abf27ad15018a6b6bcf9168d5cd1242058ab","impliedFormat":99},{"version":"bffb1b39484facf6d0c5d5feefe6c0736d06b73540b9ce0cf0f12da2edfd8e1d","impliedFormat":99},{"version":"f1663c030754f6171b8bb429096c7d2743282de7733bccd6f67f84a4c588d96e","impliedFormat":99},{"version":"dd09693285e58504057413c3adc84943f52b07d2d2fd455917f50fa2a63c9d69","impliedFormat":99},{"version":"d94c94593d03d44a03810a85186ae6d61ebeb3a17a9b210a995d85f4b584f23d","impliedFormat":99},{"version":"c7c3bf625a8cb5a04b1c0a2fbe8066ecdbb1f383d574ca3ffdabe7571589a935","impliedFormat":99},{"version":"7a2f39a4467b819e873cd672c184f45f548511b18f6a408fe4e826136d0193bb","impliedFormat":99},{"version":"f8a0ae0d3d4993616196619da15da60a6ec5a7dfaf294fe877d274385eb07433","impliedFormat":99},{"version":"2cca80de38c80ef6c26deb4e403ca1ff4efbe3cf12451e26adae5e165421b58d","impliedFormat":99},{"version":"0070d3e17aa5ad697538bf865faaff94c41f064db9304b2b949eb8bcccb62d34","impliedFormat":99},{"version":"53df93f2db5b7eb8415e98242c1c60f6afcac2db44bce4a8830c8f21eee6b1dd","impliedFormat":99},{"version":"d67bf28dc9e6691d165357424c8729c5443290367344263146d99b2f02a72584","impliedFormat":99},{"version":"932557e93fbdf0c36cc29b9e35950f6875425b3ac917fa0d3c7c2a6b4f550078","impliedFormat":99},{"version":"e3dc7ec1597fb61de7959335fb7f8340c17bebf2feb1852ed8167a552d9a4a25","impliedFormat":99},{"version":"b64e15030511c5049542c2e0300f1fe096f926cf612662884f40227267f5cd9f","impliedFormat":99},{"version":"1932796f09c193783801972a05d8fb1bfef941bb46ac76fbe1abb0b3bfb674fa","impliedFormat":99},{"version":"d9575d5787311ee7d61ad503f5061ebcfaf76b531cfecce3dc12afb72bb2d105","impliedFormat":99},{"version":"5b41d96c9a4c2c2d83f1200949f795c3b6a4d2be432b357ad1ab687e0f0de07c","impliedFormat":99},{"version":"38ec829a548e869de4c5e51671245a909644c8fb8e7953259ebb028d36b4dd06","impliedFormat":99},{"version":"20c2c5e44d37dac953b516620b5dba60c9abd062235cdf2c3bfbf722d877a96b","impliedFormat":99},{"version":"875fe6f7103cf87c1b741a0895fda9240fed6353d5e7941c8c8cbfb686f072b4","impliedFormat":99},{"version":"c0ccccf8fbcf5d95f88ed151d0d8ce3015aa88cf98d4fd5e8f75e5f1534ee7ae","impliedFormat":99},{"version":"1b1f4aba21fd956269ced249b00b0e5bfdbd5ebd9e628a2877ab1a2cf493c919","impliedFormat":99},{"version":"939e3299952dff0869330e3324ba16efe42d2cf25456d7721d7f01a43c1b0b34","impliedFormat":99},{"version":"f0a9b52faec508ba22053dedfa4013a61c0425c8b96598cef3dea9e4a22637c6","impliedFormat":99},{"version":"d5b302f50db61181adc6e209af46ae1f27d7ef3d822de5ea808c9f44d7d219fd","impliedFormat":99},{"version":"19131632ba492c83e8eeadf91a481def0e0b39ffc3f155bc20a7f640e0570335","impliedFormat":99},{"version":"4581c03abea21396c3e1bb119e2fd785a4d91408756209cbeed0de7070f0ab5b","impliedFormat":99},{"version":"ebcd3b99e17329e9d542ef2ccdd64fddab7f39bc958ee99bbdb09056c02d6e64","impliedFormat":99},{"version":"4b148999deb1d95b8aedd1a810473a41d9794655af52b40e4894b51a8a4e6a6d","impliedFormat":99},{"version":"1781cc99a0f3b4f11668bb37cca7b8d71f136911e87269e032f15cf5baa339bf","impliedFormat":99},{"version":"33f1b7fa96117d690035a235b60ecd3cd979fb670f5f77b08206e4d8eb2eb521","impliedFormat":99},{"version":"01429b306b94ff0f1f5548ce5331344e4e0f5872b97a4776bd38fd2035ad4764","impliedFormat":99},{"version":"c1bc4f2136de7044943d784e7a18cb8411c558dbb7be4e4b4876d273cbd952af","impliedFormat":99},{"version":"5470f84a69b94643697f0d7ec2c8a54a4bea78838aaa9170189b9e0a6e75d2cf","impliedFormat":99},{"version":"36aaa44ee26b2508e9a6e93cd567e20ec700940b62595caf962249035e95b5e3","impliedFormat":99},{"version":"f8343562f283b7f701f86ad3732d0c7fd000c20fe5dc47fa4ed0073614202b4d","impliedFormat":99},{"version":"a53c572630a78cd99a25b529069c1e1370f8a5d8586d98e798875f9052ad7ad1","impliedFormat":99},{"version":"4ad3451d066711dde1430c544e30e123f39e23c744341b2dfd3859431c186c53","impliedFormat":99},{"version":"8069cbef9efa7445b2f09957ffbc27b5f8946fdbade4358fb68019e23df4c462","impliedFormat":99},{"version":"cd8b4e7ad04ba9d54eb5b28ac088315c07335b837ee6908765436a78d382b4c3","impliedFormat":99},{"version":"d533d8f8e5c80a30c51f0cbfe067b60b89b620f2321d3a581b5ba9ac8ffd7c3a","impliedFormat":99},{"version":"33f49f22fdda67e1ddbacdcba39e62924793937ea7f71f4948ed36e237555de3","impliedFormat":99},{"version":"710c31d7c30437e2b8795854d1aca43b540cb37cefd5900f09cfcd9e5b8540c4","impliedFormat":99},{"version":"b2c03a0e9628273bc26a1a58112c311ffbc7a0d39938f3878837ab14acf3bc41","impliedFormat":99},{"version":"a93beb0aa992c9b6408e355ea3f850c6f41e20328186a8e064173106375876c2","impliedFormat":99},{"version":"efdcba88fcd5421867898b5c0e8ea6331752492bd3547942dea96c7ebcb65194","impliedFormat":99},{"version":"a98e777e7a6c2c32336a017b011ba1419e327320c3556b9139413e48a8460b9a","impliedFormat":99},{"version":"ea44f7f8e1fe490516803c06636c1b33a6b82314366be1bd6ffa4ba89bc09f86","impliedFormat":99},{"version":"c25f22d78cc7f46226179c33bef0e4b29c54912bde47b62e5fdaf9312f22ffcb","impliedFormat":99},{"version":"d57579cfedc5a60fda79be303080e47dfe0c721185a5d95276523612228fcefc","impliedFormat":99},{"version":"a41630012afe0d4a9ff14707f96a7e26e1154266c008ddbd229e3f614e4d1cf7","impliedFormat":99},{"version":"298a858633dfa361bb8306bbd4cfd74f25ab7cc20631997dd9f57164bc2116d1","impliedFormat":99},{"version":"921782c45e09940feb232d8626a0b8edb881be2956520c42c44141d9b1ddb779","impliedFormat":99},{"version":"06117e4cc7399ce1c2b512aa070043464e0561f956bda39ef8971a2fcbcdbf2e","impliedFormat":99},{"version":"daccf332594b304566c7677c2732fed6e8d356da5faac8c5f09e38c2f607a4ab","impliedFormat":99},{"version":"4386051a0b6b072f35a2fc0695fecbe4a7a8a469a1d28c73be514548e95cd558","impliedFormat":99},{"version":"78e41de491fe25947a7fd8eeef7ebc8f1c28c1849a90705d6e33f34b1a083b90","impliedFormat":99},{"version":"3ccd198e0a693dd293ed22e527c8537c76b8fe188e1ebf20923589c7cfb2c270","impliedFormat":99},{"version":"2ebf2ee015d5c8008428493d4987e2af9815a76e4598025dd8c2f138edc1dcae","impliedFormat":99},{"version":"0dcc8f61382c9fcdafd48acc54b6ffda69ca4bb7e872f8ad12fb011672e8b20c","impliedFormat":99},{"version":"9db563287eb527ead0bcb9eb26fbec32f662f225869101af3cabcb6aee9259cf","impliedFormat":99},{"version":"068489bec523be43f12d8e4c5c337be4ff6a7efb4fe8658283673ae5aae14b85","impliedFormat":99},{"version":"838212d0dc5b97f7c5b5e29a89953de3906f72fce13c5ae3c5ade346f561d226","impliedFormat":99},{"version":"ddc78d29af824ad7587152ea523ed5d60f2bc0148d8741c5dacf9b5b44587b1b","impliedFormat":99},{"version":"019b522e3783e5519966927ceeb570eefcc64aba3f9545828a5fb4ae1fde53c6","impliedFormat":99},{"version":"b34623cc86497a5123de522afba770390009a56eebddba38d2aa5798b70b0a87","impliedFormat":99},{"version":"d2a8cbeb0c0caaf531342062b4b5c227118862879f6a25033e31fad00797b7eb","impliedFormat":99},{"version":"14891c20f15be1d0d42ecbbd63de1c56a4d745e3ea2b4c56775a4d5d36855630","impliedFormat":99},{"version":"e55a1f6b198a39e38a3cea3ffe916aab6fde7965c827db3b8a1cacf144a67cd9","impliedFormat":99},{"version":"f7910ccfe56131e99d52099d24f3585570dc9df9c85dd599a387b4499596dd4d","impliedFormat":99},{"version":"9409ac347c5779f339112000d7627f17ede6e39b0b6900679ce5454d3ad2e3c9","impliedFormat":99},{"version":"22dfe27b0aa1c669ce2891f5c89ece9be18074a867fe5dd8b8eb7c46be295ca1","impliedFormat":99},{"version":"684a5c26ce2bb7956ef6b21e7f2d1c584172cd120709e5764bc8b89bac1a10eb","impliedFormat":99},{"version":"caee92604debc32ccab33dc2128727eb3c82e56d9af95f91f0177033893ebb42","impliedFormat":99},{"version":"c66be51e3d121c163a4e140b6b520a92e1a6a8a8862d44337be682e6f5ec290a","impliedFormat":99},{"version":"66e486a9c9a86154dc9780f04325e61741f677713b7e78e515938bf54364fee2","impliedFormat":99},{"version":"d211bc80b6b6e98445df46fe9dd3091944825dd924986a1c15f9c66d7659c495","impliedFormat":99},{"version":"8dd2b72f5e9bf88939d066d965144d07518e180efec3e2b6d06ae5e725d84c7d","impliedFormat":99},{"version":"949cb88e315ab1a098c3aa4a8b02496a32b79c7ef6d189eee381b96471a7f609","impliedFormat":99},{"version":"bc43af2a5fa30a36be4a3ed195ff29ffb8067bf4925aa350ace9d9f18f380cc2","impliedFormat":99},{"version":"b9beb5d678e6cf67901f1154f91dff455378e6aa89b20da56ed1400f3fb1f3cf","impliedFormat":99},{"version":"8428e71f6d1b63acf55ceb56244aad9cf07678cf9626166e4aded15e3d252f8a","impliedFormat":99},{"version":"11505212ab24aa0f06d719a09add4be866e26f0fc15e96a1a2a8522c0c6a73a8","impliedFormat":99},{"version":"4d647d8335edecd696fa7e59a7f2f2fea835d56d800aa2cb9278c8e5c6806815","impliedFormat":99},{"version":"c44bb0071cededc08236d57d1131c44339c1add98b029a95584dfe1462533575","impliedFormat":99},{"version":"7a4935af71877da3bbc53938af00e5d4f6d445ef850e1573a240447dcb137b5c","impliedFormat":99},{"version":"4e313033202712168ecc70a6d830964ad05c9c93f81d806d7a25d344f6352565","impliedFormat":99},{"version":"8a1fc69eaf8fc8d447e6f776fbfa0c1b12245d7f35f1dbfb18fbc2d941f5edd8","impliedFormat":99},{"version":"afb9b4c8bd38fb43d38a674de56e6f940698f91114fded0aa119de99c6cd049a","impliedFormat":99},{"version":"1d277860f19b8825d027947fca9928ee1f3bfaa0095e85a97dd7a681b0698dfc","impliedFormat":99},{"version":"6d32122bb1e7c0b38b6f126d166dff1f74c8020f8ba050248d182dcafc835d08","impliedFormat":99},{"version":"cfac5627d337b82d2fbeff5f0f638b48a370a8d72d653327529868a70c5bc0f8","impliedFormat":99},{"version":"8a826bc18afa4c5ed096ceb5d923e2791a5bae802219e588a999f535b1c80492","impliedFormat":99},{"version":"73e94021c55ab908a1b8c53792e03bf7e0d195fee223bdc5567791b2ccbfcdec","impliedFormat":99},{"version":"5f73eb47b37f3a957fe2ac6fe654648d60185908cab930fc01c31832a5cb4b10","impliedFormat":99},{"version":"cb6372a2460010a342ba39e06e1dcfd722e696c9d63b4a71577f9a3c72d09e0a","impliedFormat":99},{"version":"1e289698069f553f36bbf12ee0084c492245004a69409066faceb173d2304ec4","impliedFormat":99},{"version":"f1ca71145e5c3bba4d7f731db295d593c3353e9a618b40c4af0a4e9a814bb290","impliedFormat":99},{"version":"ac12a6010ff501e641f5a8334b8eaf521d0e0739a7e254451b6eea924c3035c7","impliedFormat":99},{"version":"97395d1e03af4928f3496cc3b118c0468b560765ab896ce811acb86f6b902b5c","impliedFormat":99},{"version":"7dcfbd6a9f1ce1ddf3050bd469aa680e5259973b4522694dc6291afe20a2ae28","impliedFormat":99},{"version":"6e545419ad200ae4614f8e14d32b7e67e039c26a872c0f93437b0713f54cde53","impliedFormat":99},{"version":"efc225581aae9bb47d421a1b9f278db0238bc617b257ce6447943e59a2d1621e","impliedFormat":99},{"version":"8833b88e26156b685bc6f3d6a014c2014a878ffbd240a01a8aee8a9091014e9c","impliedFormat":99},{"version":"7a2a42a1ac642a9c28646731bd77d9849cb1a05aa1b7a8e648f19ab7d72dd7dc","impliedFormat":99},{"version":"4d371c53067a3cc1a882ff16432b03291a016f4834875b77169a2d10bb1b023e","impliedFormat":99},{"version":"99b38f72e30976fd1946d7b4efe91aa227ecf0c9180e1dd6502c1d39f37445b4","impliedFormat":99},{"version":"df1bcf0b1c413e2945ce63a67a1c5a7b21dbbec156a97d55e9ea0eed90d2c604","impliedFormat":99},{"version":"6e2011a859fa435b1196da1720be944ed59c668bb42d2f2711b49a506b3e4e90","impliedFormat":99},{"version":"b4bfa90fac90c6e0d0185d2fe22f059fec67587cc34281f62294f9c4615a8082","impliedFormat":99},{"version":"036d363e409ebe316a6366aff5207380846f8f82e100c2e3db4af5fe0ad0c378","impliedFormat":99},{"version":"5ae6642588e4a72e5a62f6111cb750820034a7fbe56b5d8ec2bcb29df806ce52","impliedFormat":99},{"version":"6fca09e1abc83168caf36b751dec4ddda308b5714ec841c3ff0f3dc07b93c1b8","impliedFormat":99},{"version":"2f7268e6ac610c7122b6b416e34415ce42b51c56d080bef41786d2365f06772d","impliedFormat":99},{"version":"9a07957f75128ed0be5fc8a692a14da900878d5d5c21880f7c08f89688354aa4","impliedFormat":99},{"version":"8b6f3ae84eab35c50cf0f1b608c143fe95f1f765df6f753cd5855ae61b3efbe2","impliedFormat":99},{"version":"992491d83ff2d1e7f64a8b9117daee73724af13161f1b03171f0fa3ffe9b4e3e","impliedFormat":99},{"version":"12bcf6af851be8dd5f3e66c152bb77a83829a6a8ba8c5acc267e7b15e11aa9ab","impliedFormat":99},{"version":"e2704efc7423b077d7d9a21ddb42f640af1565e668d5ec85f0c08550eff8b833","impliedFormat":99},{"version":"704482f2a4a47287b195fa15c63de9188819072bc0f7635da3411ed9509bfa63","impliedFormat":99},{"version":"20c66936bdbdf6938b49053377bceea1009f491d89c2dff81efa36812a85f298","impliedFormat":99},{"version":"0c06897f7ab3830cef0701e0e083b2c684ed783ae820b306aedd501f32e9562d","impliedFormat":99},{"version":"56cc6eae48fd08fa709cf9163d01649f8d24d3fea5806f488d2b1b53d25e1d6c","impliedFormat":99},{"version":"57a925b13947b38c34277d93fb1e85d6f03f47be18ca5293b14082a1bd4a48f5","impliedFormat":99},{"version":"9d9d64c1fa76211dd529b6a24061b8d724e2110ee55d3829131bca47f3fe4838","impliedFormat":99},{"version":"c13042e244bb8cf65586e4131ef7aed9ca33bf1e029a43ed0ebab338b4465553","impliedFormat":99},{"version":"54be9b9c71a17cb2519b841fad294fa9dc6e0796ed86c8ac8dd9d8c0d1c3a631","impliedFormat":99},{"version":"10881be85efd595bef1d74dfa7b9a76a5ab1bfed9fb4a4ca7f73396b72d25b90","impliedFormat":99},{"version":"925e71eaa87021d9a1215b5cf5c5933f85fe2371ddc81c32d1191d7842565302","impliedFormat":99},{"version":"faed0b3f8979bfbfb54babcff9d91bd51fda90931c7716effa686b4f30a09575","impliedFormat":99},{"version":"53c72d68328780f711dbd39de7af674287d57e387ddc5a7d94f0ffd53d8d3564","impliedFormat":99},{"version":"51129924d359cdebdccbf20dbabc98c381b58bfebe2457a7defed57002a61316","impliedFormat":99},{"version":"7270a757071e3bc7b5e7a6175f1ac9a4ddf4de09f3664d80cb8805138f7d365b","impliedFormat":99},{"version":"ea7b5c6a79a6511cdeeedc47610370be1b0e932e93297404ef75c90f05fc1b61","impliedFormat":99},{"version":"385186398bf278346f83d74d0fa6733bc30d7403e391c70c13918ae784bcb538","signature":"3b67826fbf472e0f44d5cb98d65c6faae1129c3151c7aeed37e1311fd43a1ea0"},{"version":"c1424847f8905ee22d15ce094f27ac27a0b33801fec847dbaf9b1239a5c2abd9","impliedFormat":1},{"version":"222ca30f5d8caedf7c691abb6ec681b4fe9d6a6008418f0c5f27ca64ee30e536","impliedFormat":1},{"version":"503c2d4238fb9e95fdfe87cab5e1683a673515e76516514ba1c571697a8d9655","impliedFormat":1},{"version":"2c378d9368abcd2eba8c29b294d40909845f68557bc0b38117e4f04fc56e5f9c","impliedFormat":1},{"version":"bb220eaac1677e2ad82ac4e7fd3e609a0c7b6f2d6d9c673a35068c97f9fcd5cd","affectsGlobalScope":true,"impliedFormat":1},{"version":"c60b14c297cc569c648ddaea70bc1540903b7f4da416edd46687e88a543515a1","impliedFormat":1},{"version":"a43e9687b77e09d98cf9922bfe0910bb0ed7e5b910148c796e742764ce7dc773","impliedFormat":1},{"version":"faa03a3b555488b5ce533ce6b0cf46c75a7e1cd8f2af14211f5721ef6ea20c82","impliedFormat":1},{"version":"43c39d43de6c598e908401ed15ab7ba7d3e1b34460003025ea62ad48418dde98","impliedFormat":1},{"version":"80c3dbd0388dfa12adaab2ba562b961d79eabaa5f966dea4a59954effa7dbe8d","impliedFormat":1},{"version":"650c26b5a44787da1b03c89a3a17b2c6dc30c6f152c6314389298759e6a59275","impliedFormat":1},{"version":"e014c4f7e51d02f2aa47b21a45ab1313235283a07dc039dd2ab7a104f64da7f3","impliedFormat":1},{"version":"63b3480521274886ca85e33a7dadbd5052d3b5f3313800355a42428ea0361a96","impliedFormat":1},{"version":"f734b58ea162765ff4d4a36f671ee06da898921e985a2064510f4925ec1ed062","affectsGlobalScope":true,"impliedFormat":1},{"version":"acb93abc527fa52eb2adc5602a7c3c0949861f8e4317a187bb5c3372f872eff4","impliedFormat":1},{"version":"37f96daaddc2dd96712b2e86f3901f477ac01a5c2539b1bc07fd609d62039ee1","impliedFormat":1},{"version":"9c5c84c449a3d74e417343410ba9f1bd8bfeb32abd16945a1b3d0592ded31bc8","impliedFormat":1},{"version":"a7f09d2aaf994dbfd872eda4f2411d619217b04dbe0916202304e7a3d4b0f5f8","impliedFormat":1},{"version":"a1e2b9e55ddf6cfa9435f3a7026380749fda2f5a9f8dac57f4c5e1f40f53bf3c","impliedFormat":99},{"version":"fca68ac3b92725dbf3dac3f9fbc80775b66d2a9c642e75595a4a11a2095b3c9a","impliedFormat":1},{"version":"81c4a0e6de3d5674ec3a721e04b3eb3244180bda86a22c4185ecac0e3f051cd8","impliedFormat":1},{"version":"78d030052390a253a1ee7675591425671de366f6964130a8e148a2166d6fc452","impliedFormat":1},{"version":"223709d7c096b4e2bb00390775e43481426c370ac8e270de7e4c36d355fc8bc9","impliedFormat":1},{"version":"61a03761af9f60417c66882a48eb383957bda5987393d2f32e1ed104e8d48f15","impliedFormat":1},{"version":"2b8a883d217f55290af714b87ef738e32e0b99984b23b0f82a98caae362e7451","impliedFormat":1},{"version":"d5e806fbb24521445d9e5b11bc3fd626fdb2c0b11d3a8f96f9b68ea402cad9fa","impliedFormat":1},{"version":"7261cabedede09ebfd50e135af40be34f76fb9dbc617e129eaec21b00161ae86","impliedFormat":1},{"version":"ea554794a0d4136c5c6ea8f59ae894c3c0848b17848468a63ed5d3a307e148ae","impliedFormat":1},{"version":"26d9ea4d13529d0e6192db96841b264f9a0fc9236fe234d96cdf8e8141c24576","impliedFormat":1},{"version":"94c8c60f751015c8f38923e0d1ae32dd4780b572660123fa087b0cf9884a68a8","impliedFormat":1},{"version":"690c8311d7bcf6e2d2fb143335aebedc8025e9bbd5696da3d7fa35cf5ec5b6ac","impliedFormat":1},{"version":"685a189e1adddbdfd0eaee9f42df9e77e89fb60756305a398d8ee480148b6678","impliedFormat":1},{"version":"c5b47653a15ec7c0bde956e77e5ca103ddc180d40eb4b311e4a024ef7c668fb0","impliedFormat":1},{"version":"fb7e20b94d23d989fa7c7d20fccebef31c1ef2d3d9ca179cadba6516e4e918ad","impliedFormat":1},{"version":"8326f735a1f0d2b4ad20539cda4e0d2e7c5fc0b534e3c0d503d5ed20a5711009","impliedFormat":1},{"version":"8d720cd4ee809af1d81f4ce88f02168568d5fded574d89875afd8fe7afd9549e","impliedFormat":1},{"version":"df87c2628c5567fd71dc0b765c845b0cbfef61e7c2e56961ac527bfb615ea639","impliedFormat":1},{"version":"659a83f1dd901de4198c9c2aa70e4a46a9bd0c41ce8a42ee26f2dbff5e86b1f3","impliedFormat":1},{"version":"a66f3da7de689a5879af9501bbae12a28b42194e0a364afb7a6d395b3e3813c3","impliedFormat":1},{"version":"a0baa826317f013ecb3e451192a309b591f430432dddfec349fc61a11e9c44d4","impliedFormat":1},{"version":"953440f26228d2301293dbb5a71397b5508ba09f57c5dbcd33b16eca57076eb2","impliedFormat":1},{"version":"beb6995acedc0239d062124022004eb8341fa5eb62d9c867c1881c04f4233797","impliedFormat":1},{"version":"1b6358a3b261d9e6096154f9b5aecaddba845c95335d021e87a5626962092bd3","impliedFormat":1},{"version":"64aff4bce69cccfd193353af05e8b3ae3125c009969d2dda49072ec297e2fc82","impliedFormat":1},{"version":"cb4a9bad89a226da94b70cd0cca2010ffde636f34022bec7fc69caf9e6ad8e20","impliedFormat":1},{"version":"43587ce13d0b0bb9f6ee8363020d8521102381cefb4b650b1c4ae9ad56ed7e07","impliedFormat":1},{"version":"3f3526aea8d29f0c53f8fb99201c770c87c357b5e87349aca8494bfd0c145c26","impliedFormat":1},{"version":"e33bd2b4ebf93c3bb248d845e3751f5c31731268ce71bc38f99ec44e64daaab1","impliedFormat":1},{"version":"1801a58e8cbd538d216fbea6af3808bd2b25fa01cf8d52dba29b6b8ac93cb70c","impliedFormat":1},{"version":"4326dc453ff5bf36ad778e93b7021cdd9abcfc4efe75a5c04032324f404af558","impliedFormat":1},{"version":"9b597900f033ffe72808c6c39d62142c920499e51748a247d2f9dc16cdd3bcd5","impliedFormat":1},{"version":"64843c2f493a1ff3ef8cf8db3cff661598f13b6cb794675fc0b2af5fdb2f3116","impliedFormat":1},{"version":"0e447b14e81b5b3e5d83cbea58b734850f78fb883f810e46d3dedba1a5124658","impliedFormat":1},{"version":"bcd9c89a593fc73c694bb5e06c8bf7c6bdda0ac491195ef364d9dac5f7db0f03","impliedFormat":1},{"version":"929939785efdef0b6781b7d3a7098238ea3af41be010f18d6627fd061b6c9edf","impliedFormat":1},{"version":"6eaab464388a8b742621def40c40932bb0550813a32f70df10ecb6b2884c0c8f","impliedFormat":1},{"version":"fc94f97b7dbe8def50e4e6441cfc957a82e103358153b4bef1bf83d02c015ef0","impliedFormat":1},{"version":"6052522a593f094cfee0e99c76312a229cf2d49ac2e75095af83813ec9f4b109","impliedFormat":1},{"version":"7601b760d7679d3d678771b0719cb43b9406a3e10122da583f11b34ec96ebdbc","impliedFormat":1},{"version":"a63ce903dd08c662702e33700a3d28ca66ed21ac0591e1dbf4a0b309ae80e690","impliedFormat":1},{"version":"b9a7df08c1eebb4be745018c2eb1274bb8f3c833806a80bee366adeb6345bd4e","impliedFormat":1},{"version":"0e112389b534d19d42f5033e73cecbf189c7f1666853eb453649ae490595bb27","impliedFormat":1},{"version":"8f4844e37b671b16f618029c46ed308f8eecf129f7465d20f150b0bc2b505ac2","impliedFormat":1},{"version":"2ce8dcdc7d6ba8e1702e1d4aa2687d62990678ab518e26ac4d5495aa78199b14","impliedFormat":1},{"version":"b34fe66e28be3aaf3987b2ebb0f6553e63c54ba9d24ce81dc8666a472de5f46b","impliedFormat":1},{"version":"6e2d2b63c278fd1c8dd54da2328622c964f50afa62978ed1a73ccd85e99a4fc7","impliedFormat":1},{"version":"8bc28fd0aeb868da5ab03d778b6bfc14fd0243bc04495d0d897cb7e3cb4bfca8","impliedFormat":1},{"version":"f642b9a36789a744a3f269de516bdd08675bceda13ee45d26bc0302e9ec2dabe","impliedFormat":1},{"version":"6ce50ada4bc9d2ad69927dce35cead36da337a618de0a2daaaeeafe38c692597","impliedFormat":1},{"version":"13b8d0a9b0493191f15d11a5452e7c523f811583a983852c1c8539ab2cfdae7c","impliedFormat":1},{"version":"e8f45424b7cace1ce8c65052d4ee0c014b22e5aa3c114ae6fea32cef0f3d9c82","impliedFormat":1},{"version":"068f5afbae92a20a5fcd9cfce76f7b90de2c59a952396b5da225b61f95a1d60a","impliedFormat":1},{"version":"e97649774336f99385c03380cc4a1dbab65123c35cb3172f36ddef2f319a2ff9","impliedFormat":1},{"version":"a99bbc08536893273b1faa9c07c59c862f0fd363475a31d0c4b7bfc6df170c35","impliedFormat":1},{"version":"33a2af54111b3888415e1d81a7a803d37fada1ed2f419c427413742de3948ff5","impliedFormat":1},{"version":"0d364dcd873ebebc7d9c47c14808e9e179948537e903e76178237483581bbf6c","impliedFormat":1},{"version":"3fab75b3b823bf174ea1cee355e5bfb222277da1f8f9848f42150a05f5c3921b","impliedFormat":1},{"version":"14e655243975208ff46b52e65b9b36e3225dc610ffdd61afd8878565e2b62f3d","impliedFormat":1},{"version":"8c4224b82437321e1ba75fd34a0c1671e3ddcd8952b5c7bb84a1dead962ff953","impliedFormat":1},{"version":"e65e42a4d26b35a605baf789c348ee70220f72995c5ee6128a40328d3e8701c1","impliedFormat":1},{"version":"b5f27501077287cafa1257a91181b02c2c5fc6118206974960ee35c947bff460","impliedFormat":1},{"version":"f5f41e3a8df5eaa79ba16ae9c5f114beae9c2b32bb976a6175ecf3e2e975d10e","impliedFormat":1},{"version":"8a705ea6df44796af9df7704e6b7bc4fbff126fce0066fc9719936cc5668d054","impliedFormat":1},{"version":"fc8f837ef36ac7748fed8d55cce33bb3b3e8c10082f1f42512606c9b91e71b74","impliedFormat":1},{"version":"d080548751209b1ebf7f8e6284a82d8f87998fedce00f3872f513d4c11bad9d0","impliedFormat":1},{"version":"0f8107c8cc078f31adc9e1928c6f7b33230223f143ae183468a5ea3a7889b55b","impliedFormat":1},{"version":"38a131409a186927cc36d6cd16b9195a370082ff4cbecf60b23c9f7e5cd39901","impliedFormat":1},{"version":"81b262fe146dae64043337c7479a43b6ae67e74ac02c0729769e3d6e76d4d858","impliedFormat":1},{"version":"3051e0c946698682b8746ff3224ae5237435852c42a5179275358d5f547b71f7","impliedFormat":1},{"version":"4c7aa04345d784f2c8f96216370dafe86435add65ad0adcae5c1d2b82cd40a05","impliedFormat":1},{"version":"8fece074d02a27532eb2285f4f6803e98d7db8c956218d996910f2a961ee0fab","impliedFormat":1},{"version":"28675d40ec83b792b3003736fb009851b9729e70b7c97639625a0af5da4e0596","impliedFormat":1},{"version":"ad750b859d04354baa92aa0f02aafb3948ec2ae53c57906749ce94a0a2379ff4","impliedFormat":1},{"version":"4e8cec3e1789d0fe24376f6251e5cbe40fc5af278c7505d19789963570d9adee","impliedFormat":1},{"version":"7484b1e25cc822d12150f434159299ab2c8673adf5bd2434b54eb761ede22f76","impliedFormat":1},{"version":"9682bab70fa3b7027a9d30fb8ae1ee4e71ecb207b4643b913ba22e0eaf8f9b35","impliedFormat":1},{"version":"d7ed6d8bcc8c8d86a4307178e89cad6c88aac374fe87804c0bc7a0cc52c61a81","impliedFormat":1},{"version":"cff89395b8a7727af0a881b510273d74ce9df0fb6b640f6f4ce21da067485c2b","impliedFormat":1},{"version":"b713dea10b669b9d43a425d38525fc9aa6976eff98906a9491f055b48ee4d617","impliedFormat":1},{"version":"fb0ca8459e1a3c03e7f9b3f56b66df68e191748d6726c059732e79398abb9351","impliedFormat":1},{"version":"f83a4510748339b4157417db922474b9f1f43c0dc8dda5021b5c74923ed9a811","impliedFormat":1},{"version":"3d04566611a1a38f2d2c2fc8e2574c0e1d9d7afd692b4fcd8dc7a8f69ec9cd65","impliedFormat":1},{"version":"0052687c81e533e79a3135232798d3027c5e5afff69cd4b7ccc22be202bbbf4f","impliedFormat":1},{"version":"aa585adb25c3751a39bb6c6663ab1988f6dfd46f8225c0da12719e060562939e","impliedFormat":1},{"version":"a49ee6249fff5005c7b7db2b481fc0d75592da0c097af6c3580b67ce85713b8f","impliedFormat":1},{"version":"b88fbb95e567a0fa2df81bdd82b88b13545d79453787bda4543c0369f4f6d568","impliedFormat":1},{"version":"fd4a83bdc421c19734cd066e1411dae15348c25484db04a0a2f7029d1a256963","impliedFormat":1},{"version":"af31f37264ea5d5349eec50786ceca75c572ed3be91bdd7cb428fdd8cd14b17c","impliedFormat":1},{"version":"8d56fb4ae16943117591d60ffd52f4544affc46c44111b492d4f2ab51ff5268c","impliedFormat":1},{"version":"40683566071340b03c74d0a4ffa84d49fedb181a691ce04c97e11b231a7deee4","impliedFormat":1},{"version":"c53674e899725630a469dadd5cd0827b85903d5435afb784cacbe41c5e8c9eef","impliedFormat":1},{"version":"e885933b92f26fa3204403999eddc61651cd3109faf8bffa4f6b6e558b0ab2fa","impliedFormat":1},{"version":"5852ec0e134dda28852eada61248ab2b8027aa1238340ccc407234f013627f61","impliedFormat":1},{"version":"0463dbee62e1e2f1692ece7b08d31c329e642114355426606b390aab7978414e","impliedFormat":1},{"version":"f6bf2b22f3af7ddb26f9a93b47f8747547ecb598ca5b3002d9e76f72a65809b5","impliedFormat":1},{"version":"6733e3a832f92b68e7368878cfb4e54a4b942361e87a0b8fa2a475ec9369ad03","signature":"e05f7241b9f0d8920509251c4334b674d7dfe32fc4dd7901c62508cf53424b0d"},{"version":"17c51c1633a7319e25ba1a52fd4af4cc47d6cc29d6d5fb8cab402aaa343f564e","signature":"bfa004f2f9c7aa15ae4065af42d2564124d5a3cdbc806aff60e8ea1646355417"},{"version":"5c1b479320c1e8727815f025889d437a51d7d9864141e1f2482b28ea65dc322c","signature":"0e9d205bf2e600c2985999726bac6490e2c0ed9e3646cc1e0e7f988b9463f9a6"},{"version":"31c30cc54e8c3da37c8e2e40e5658471f65915df22d348990d1601901e8c9ff3","impliedFormat":99},{"version":"a6f9e326f19cfa485b3a6c2eb7b9829c42f8012f29820cefab0b10dd5c1cb2fa","signature":"870119a5f3f2da219ba16214980357bbf0dd1f2bcfd77fd35da7d8465c0ae708"},{"version":"9135f91ac9d46319f80ec11ddba53a00d74d519225d95de95991ab462eaafc40","signature":"e2158e02c8b496405b7a72c204a6359767d99f2753f3287069063f0c67e31c47"},{"version":"851a40eac92a3e62a13d00a2035c7e590488f14d85eef3cd06f4f1a042982374","signature":"32b0db64f644e850ed98b38c5cc0a938e68a706f3948a95cd48fd0c012bd2e2b"},{"version":"fb53d08863f113ec1c8bc2c5d543d625551e28e401b29e5988f6ce4259ef935f","signature":"8670ec89de827a6e9d8f0f268b29a415094ea5137e91e60da027ded8ad5cc098"},{"version":"fd432f424507ee57ff25fc592c2a0b16f28fa56deb4df236653654ecec348789","signature":"81e691d34825e62f13beb4439db7e04a3a7b4610ed434bc8b7d0e2f05436fb75"},{"version":"d3cfde44f8089768ebb08098c96d01ca260b88bccf238d55eee93f1c620ff5a5","impliedFormat":1},{"version":"293eadad9dead44c6fd1db6de552663c33f215c55a1bfa2802a1bceed88ff0ec","impliedFormat":1},{"version":"206e73f49f16633113787cc651dc03dc900379395dfa02ab1ef4c9cbbcd5adc2","impliedFormat":1},{"version":"fec412ded391a7239ef58f455278154b62939370309c1fed322293d98c8796a6","impliedFormat":1},{"version":"e3498cf5e428e6c6b9e97bd88736f26d6cf147dedbfa5a8ad3ed8e05e059af8a","impliedFormat":1},{"version":"dba3f34531fd9b1b6e072928b6f885aa4d28dd6789cbd0e93563d43f4b62da53","impliedFormat":1},{"version":"f672c876c1a04a223cf2023b3d91e8a52bb1544c576b81bf64a8fec82be9969c","impliedFormat":1},{"version":"e4b03ddcf8563b1c0aee782a185286ed85a255ce8a30df8453aade2188bbc904","impliedFormat":1},{"version":"2329d90062487e1eaca87b5e06abcbbeeecf80a82f65f949fd332cfcf824b87b","impliedFormat":1},{"version":"25b3f581e12ede11e5739f57a86e8668fbc0124f6649506def306cad2c59d262","impliedFormat":1},{"version":"93c3e73824ad57f98fd23b39335dbdae2db0bd98199b0dc0b9ccc60bf3c5134a","impliedFormat":1},{"version":"a9ebb67d6bbead6044b43714b50dcb77b8f7541ffe803046fdec1714c1eba206","impliedFormat":1},{"version":"833e92c058d033cde3f29a6c7603f517001d1ddd8020bc94d2067a3bc69b2a8e","impliedFormat":1},{"version":"8e6427dd1a4321b0857499739c641b98657ea6dc7cc9a02c9b2c25a845c3c8e6","impliedFormat":1},{"version":"58da08d1fe876c79c47dcf88be37c5c3fab55d97b34c8c09a666599a2191208d","impliedFormat":1},{"version":"2576c3edc78797e0206c738577de487893253780821e977c690eeeb1bc4c3b71","signature":"efdd399105978f071ab08cbbd26ba9774eb8bc990875bcebbaeb7107c14b9abe"},{"version":"e0abef7b1ec7dc3ad032e42117b71af506dac4ab72de066f659d03eaa72c0fd0","signature":"f6b3e4bb6826a124241d49968dda0d6990bbaf6be48f1c51761e103543100be2"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"cc3738ba01d9af5ba1206a313896837ff8779791afcd9869e582783550f17f38","impliedFormat":99},{"version":"3b217e02ad520f3d63c5ccc6d8870c91c1da51d8c0f09e834c3415ef051c1dfb","signature":"e7f0196b8c2cc640e4d5841868b7ce67c41d306262e568d0132ddafab39bc157"},{"version":"17247b09a117c79610d682568e2ba37566d96d2333d3540a66d0f8755a54893c","signature":"dcf0caf6d631c1007de4e649c1fb92791bf5ac0eb55d286bffd7cf12ab399d66"},{"version":"60583b38c087b1b225aa077efba28c701eb1f0e1d1705a6f2f6a7e230df016b6","signature":"0bf3a611a7c2af01c27149e0b9fe9c61af5a287b74b266f0f0ebe7dcf339ad5e"},{"version":"27ee9f713987f8a884c7f8cd7743a10457f1768170cfe9750d84b0a158c5c486","signature":"73e926168d0f3f2ea7932a8fddbc68b69e4f089597b7a6ce13ce42a5a89440ab"},{"version":"64c6bb953b8d78268eadd3539bd97e09eac8bd2b736f80c6fb96f3585d830e9e","signature":"29de3fc2a14cc92861e585b05d11a88332ff1a12ea656e49b449062062b31350"},{"version":"047ef8187c382abbdd2d751ef1a5c4fb065aaeef6557483e2bd6d7ec6153aa8f","signature":"74052560a70381575989a8c7787e5c6094299ea4ef6b4bd9c7b49e1480c40eec"},{"version":"3c7819d0bd2370ec46aa83ddd33c9a0b177e9e6587a7d94ee9a6d6961540ec6f","signature":"34817f7aafffd4d1b276bb56dafa1ff55e6f38336862dbd0efe15e83dfcfcdc5"},{"version":"6d3bacd5150ba69409c66fdd6d34dd40936319692a793d0d313d5834a48c5b4a","signature":"e7ae15fba5ca5e6f6c5feb87053b004ef3e7ed91c61811dec07b556028050c29"},{"version":"be792b42c05869e896f568e71def7ba7bac468627af490c365c5505c1f47331d","signature":"607ba59accf487aab11426feca0692067d4fcaf1bc7293f7db32561a01152a84"},{"version":"8186fa14d654c52ea6e14295e62f1406c1db9ffe6634277303c827431b79e161","signature":"a7ba3eaa8e25a7afe27773d0b351c7035efdbe04bb47dd3f26b5a9a8f3a6e281"},{"version":"cad85d394ee648aa5c94ab37ba8c6d8279c3a46a0f67295b8bd7e3d5d64fdbc7","signature":"ddce3db9495e56c599668c462b6c864917787b33f19b2a44decd6b5e27efbf72"},{"version":"e7441be68f390975c6155c805cea8f54cc1b7f3656b6b9440ecbbbd7753499e6","impliedFormat":99},{"version":"5a99d073185e0ef6d984436547dce1f99c333dde7c1d7f33a2155dce05216514","signature":"a62a952464813ad6681414a2f6708d8d8cb5ccb7ee948cef6e7f7d6f11869795"},{"version":"56897393338cb1107179ac9a54d38e0d5c6e4a38354c4b522edf8160b2ec67b1","signature":"146bd7877b9f34f55391ab85bda586a238d968c8736489eeff793ac266704d2d"},{"version":"ad14d7864ec595f8f9224a085083fffd0137150d803092803b146643434d48a7","signature":"ade22b42ad26354dbff601e10439a06d15581696425231bd83fe6517a9438b0d"},{"version":"b5709d2685ca90ea786a0dada56b710eaccfa6076327e4499c9ec86962f99aa7","signature":"e9215c110843d60cdcf28e5fa8144522681de43094a89e06e3855f7990f49a7f"},{"version":"5d0c5e767bf2a6f08629a58b6a89b7d91a81f6e35d9167bfda0bd9f1e2357b4e","signature":"f515561294f9cdcee8482e9c653ee65f600d63832257edb86a2f2f5a0cc1b64e"},{"version":"2a8ab4ff76618819e70fea2c26ac539752081c533ef71c54bc277ca5189b3b4c","signature":"b819d8b90a2f2e2b67c15c59eed25430cc7ed831fd114e567ff88833fa4b5de5"},{"version":"06e929e9486848966c3e11ee218dcfa7dbd60a9090fbe979c7dbd0bfdd1979cf","signature":"97b88cd12c3dda2a5fc7c2e658d589781dd5aba8920d00c252a623198190e172"},{"version":"e1e3a9b51aa9eb884d3aece89c538bfd17405681917401afb2ba9a464426161c","signature":"646228bb4dfcdb32d9eb2aa9a591f2f2d752e7ad1c9bbefcd99ed31c11431bc3"},{"version":"51fd4e47b5fa7549a2c8f416fb360945e3a9b5050e9d5975dfe4e642684a737f","signature":"9dff8a85e580b32a38517861c4adeaa44f516d226f8762207a57be459aa996ab"},{"version":"7950cde48ecc99f323e3c86093a465d91a33aee84f4a2888364944f8c3febf0c","signature":"6eb9299d651ae2913fde0d9f9c71d13bbd867e7b3b4168a1e1d5ef1d58c99ce1"},{"version":"4012abed7b39073f7497b340722ccf697db4df2b453fe6618656282d235e1172","signature":"9523d5e15d8d5ebbe2ed48703bee4197fabf986d30da5f3377ec2c7256062b59"},{"version":"2ddbf67b826f80f978e93a798a2bccc8867c4b8bc46c69f86634401e2d336dad","signature":"abec593d0c5872aced84afb7046990d70b3016feebce6e521e6845d7998a219e"},{"version":"0b5fb5eca5212255296bc4a6559e4a02d253d2ae2d6fc2b62fa285cdfec3786e","signature":"ea30d960932ca79984691953e1c38879c34a3dd702bca3b68b06947169e9e829"},{"version":"4dff76748f5251bd396a7cf3277665fde991f269758b6037a018c9835a80cdff","signature":"33e3c704d99c17ecad61fc416168523cab5b346af5801d101657a23759902fe8"},{"version":"6706be8adddc5a11c7a04d42f0c0dff0f152065d20eba21f9d113917ce879d33","signature":"ceee79c89d2c30c728888df3196527bfb97e65d34b77f98f332951aef3c495b4"},{"version":"21f41ce5777146a8d8e525ad31cc8d364bb9f8508ebd7a01e77733b567fcbc0f","signature":"690bfa869de9227da8088d725491edf0c11b2620e734c02f87ac2253323b71c1"},{"version":"3c4b1655c3b560fc2cf010c1362514856812640f3db32bf05f4490ef174020ab","signature":"23cab6ce06696279720f09a214c67d4e9ce8bf93a8de0e18a4549310dee9df25"},{"version":"23a6e9e2fb0ce3ea299b33e644dc16975d5889443adf27ecea3d946fe642f2ad","signature":"7e87d6db36a5ece2b70f2d632b43eb21ed5c39e6f1a3860af966df12c5ee6bcc"},{"version":"cd8d704e31ca6e772eaaed0d1abbda5131968d07da6295ec31ca25f2f96f4603","signature":"8d23da0bcd77e78b20a2f20624973b039d3013ebf0fabd0c8e0615c58e74489f"},{"version":"fd432f424507ee57ff25fc592c2a0b16f28fa56deb4df236653654ecec348789","signature":"81e691d34825e62f13beb4439db7e04a3a7b4610ed434bc8b7d0e2f05436fb75"},{"version":"6d3bacd5150ba69409c66fdd6d34dd40936319692a793d0d313d5834a48c5b4a","signature":"e7ae15fba5ca5e6f6c5feb87053b004ef3e7ed91c61811dec07b556028050c29"},{"version":"734c978a53643112e0939f3493758ff2651ca56aa92f180cda3a0542274baff6","signature":"5710b2220aa08a5cdec279bc67698116171d4334ca0dbdb19e1b0f1e923f2523"},{"version":"6694c6c2fcd64787415f92325073b8c07f18331d6662c6f7ef910983fb224973","signature":"0defc2e1319ef7d837b4ce14309e72f18dec48d60f4c393063e51320e5c02db9"},{"version":"84ff40be4b13a68ebf42f3d41d085dcb3da5caaefeaf072febb90ac5fba38c46","signature":"284a8609076cea2eda4a190c556d66757113720b785a1b2819ff44cae0b033c2"},{"version":"13680c9726421b79c1957bf5f06d3deec35e7e5a113c49583b037ffab6ec6d39","signature":"c3b82b731c1bfda402eba10f9df571580d1f5a674d5ca43ce97a933ee02c2d22"},{"version":"1ca52accaf2273cc86e913b388ba0c36f4e4d8e19b3f9b015e81eea6c4ae5960","signature":"2a618d1e67da91688d27b94c9b241bbfba39b5cc1634eec5587a9288744c45c3"},{"version":"d752035cf295253d806c763d4f1ffcfa9afe49210355fbfd8b833376e56e1109","signature":"a9f7d0693bbfc1b3167c19e6756b12e8acc591d96dbb553a5a4a27ba4e4a35b4"},{"version":"c1a2518a277db331f5506a94c74afcae9f9d3287ed659b7a91407c28ed6ed6c6","signature":"63bde153cfa3cf0afe2a2a36aafa1a130e4b2caf41652c5d1dcbfaa0d6a9148c"},{"version":"5824604e17ce23f1d5aa3ce8092e4c284897551816aad2532e17477c597aaa7d","signature":"e27aa7e6f6113a7b2c84125c2b9a273b8c06c822d94d1bdca4cdb0aa4ce5de0e"},{"version":"f142d5c2f148ecb72e45eaa5152a642ab1956e0a3235896b2eda30a6c4a8e0a8","signature":"11f5be9abc00c11cd52420abfbc71561ec3cdb19f272077b1eedfc066110e2f4"},{"version":"c351dc34a026a2e3ea1b23b2eb0d9d95a60599a156a6029d03607de67e715627","signature":"f138d5ffbc374cc396b5347b8fd34f866962b2540e7d85b69c0de168946ee499"},{"version":"f48eb40e426a9c3cf66bc5fe145bec945f186964536f0a8366cd2d0997298b8f","signature":"b49934ea0ebed672b4554b54ebf5047afe63d4212a629920553e3c4f98d1e210"},{"version":"a9373d52584b48809ffd61d74f5b3dfd127da846e3c4ee3c415560386df3994b","impliedFormat":99},{"version":"cbfd5ef0c8fdb4983202252b5f5758a579f4500edc3b9ad413da60cffb5c3564","impliedFormat":99},{"version":"956cf4b485bcf57684caac10df2aa2a72387d0736d8f4cd1315c49ebd2da4615","signature":"1eb20268ebe644e6df6078e14bce71cc71590d43c562b4d3fdc2375777bca31a"},{"version":"caf4af98bf464ad3e10c46cf7d340556f89197aab0f87f032c7b84eb8ddb24d9","impliedFormat":99},{"version":"233267a4a036c64aee95f66a0d31e3e0ef048cccc57dd66f9cf87582b38691e4","impliedFormat":99},{"version":"0397ed074259c28d961b3567cf425d491b6b434fff93bc25eea2fc93bbd75f7a","signature":"b49f7ee0feb128c542b7a46a8af92fd18942b5460e80d7be8aabd8ce507764d8"},{"version":"b598b1e9481a930b5f9e38e0e41a4267722ecb641d41a46ad04a0873fb92eb31","signature":"00ca1d2d1160f655bf2eb98c3454f9043ec52d5c63d7c8b360122b4afe4c27d9"},{"version":"9990f21aad5b08bd1367c26eaf653379fbd3cbf1c73835d7c89558a897cdb9e4","signature":"ffa79f62c536266410190ee8d522f68b1e8a1a01fb705451c8c2c987df92e062"},{"version":"1dbd248b251538341f7b6d921c1972569ec7f3f7f5897123fc00148f6bdc0e57","signature":"354030b88a182802d063fb8096a34d9d23b69d2f48db10277488475dde054919"},{"version":"42adab75a647248b224a23d3b6b398efcee1b6b417cdcc4f32bc50cf6fba266d","signature":"6912fcc8e7b93e970fc0018c59d7606df75f8d62b342ef5e9d74eb08ba50b6d1"},{"version":"ab85664862c198191ba3d77d3a0e271a26c949093cabd88b74f5079484b3c69c","signature":"ca272dae169954a9e3dad0b8ec2acc9b69b9c292508909a8ddd4f9412a01e6c3"},{"version":"c0b208999b2e53020a7b2a1d8d4ac67bec87651389bd630ac2e8d632fa839b10","signature":"17d95f0fda80b532996dc589a631ac937896df66be49ac9b0b381e028dfe9e85"},{"version":"c892fb76ede9506711319412d369bc666c1a574d16d6559f0aea873d55d07cfc","signature":"f23885a1b16d6b8c10966100c439eef43e2a0a82c0a43c2abd239f01ea9188be"},{"version":"146072a9d4178049116796062a37421cdf09f0bd06390a69a1fb76daf71dcb11","signature":"3a663b83bd70cae5c1b7e453f52eaab61f1f382c44d69c7b4491da5058239b2a"},{"version":"3aa160f473ca0af44d500c6bed1af5f5d9ad4ffb2884b4ca34e59989dd5d90e4","signature":"c416f65676cd621ef92478b644323536b31d366476693fa2f9a15063cd1d6ff5"},"2552a31fad45a9ed1bde87e51b038dc0e786cd364b597162263abbf57018949b",{"version":"6c1b1a7df2ef20edea7af3b853134925e9fe26e3f6cb51b04201ecd6ae35e284","affectsGlobalScope":true},{"version":"8fcfb6aa682f394cf1b20f5b3d972a03b45bc891226661412bf9740b66b53d37","signature":"8e609bb71c20b858c77f0e9f90bb1319db8477b13f9f965f1a1e18524bf50881"},{"version":"1ff6028b5b6ccb9af8d5789deaff14ff09a6ab61cdb619eb383395989edffa2c","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"386b6553763e4688817838bf6cc7d51a504cac0dd9ca96f46600874fbb72dfad","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"7e684095a2d1cdd296f6c85e01108415c3ac1bc7d9e4e2f53794e9bea9c96209","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"c454d311382b04274c7162009563df77518ab6efa55f0514e550dfac17194b7e","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"a9fb08273dc91752f3f65cf26761a7d680b131bf624989e53965da7cbaff8c6a","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"b6987d179737a82a85e4004adf041b441a8fda6f31ce061bd57eaa8cdca0c46f","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"f6f8307d1cd2a2f262f6a03d1bc4eaae1008540dd689749a1d55817bda99ddd4","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"a3a089cb140f7980edee0e43343dd59e0bdc66ce81a73ef166f63b9ae9780ea7","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"ccc04dc065d5c8b3a168449d48ad7d7f56f5074578d73503767225c2d1cb52cb","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"c609171dc1f4060d39c937c4271322c028f0bc6387c439b8bc0bdfa966e1c463","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"39749520c8e365ea4ac255752171fc222f4961d5e6d15ff24c3a76807178ff41","signature":"89b0f68f8f0b901f9dfff2b9e7255520283a783d6af7f2bc2953d771232317a2"},{"version":"b1538a92b9bae8d230267210c5db38c2eb6bdb352128a3ce3aa8c6acf9fc9622","impliedFormat":1},{"version":"6fc1a4f64372593767a9b7b774e9b3b92bf04e8785c3f9ea98973aa9f4bbe490","impliedFormat":1},{"version":"ff09b6fbdcf74d8af4e131b8866925c5e18d225540b9b19ce9485ca93e574d84","impliedFormat":1},{"version":"d5895252efa27a50f134a9b580aa61f7def5ab73d0a8071f9b5bf9a317c01c2d","impliedFormat":1},{"version":"56208c500dcb5f42be7e18e8cb578f257a1a89b94b3280c506818fed06391805","impliedFormat":1},{"version":"0c94c2e497e1b9bcfda66aea239d5d36cd980d12a6d9d59e66f4be1fa3da5d5a","impliedFormat":1},{"version":"1f366bde16e0513fa7b64f87f86689c4d36efd85afce7eb24753e9c99b91c319","impliedFormat":1},{"version":"151ff381ef9ff8da2da9b9663ebf657eac35c4c9a19183420c05728f31a6761d","impliedFormat":1},{"version":"f3d8c757e148ad968f0d98697987db363070abada5f503da3c06aefd9d4248c1","impliedFormat":1},{"version":"96d14f21b7652903852eef49379d04dbda28c16ed36468f8c9fa08f7c14c9538","impliedFormat":1},{"version":"7fa8d75d229eeaee235a801758d9c694e94405013fe77d5d1dd8e3201fc414f1","impliedFormat":1}],"root":[83,497,502,510,511,[517,528],[531,537],542,546,[560,562],[567,575],[578,596],606,[612,619],692,693,[725,747],[749,757],[760,776],[781,802],[906,912],[922,927],[931,933],[937,952],1386,[1502,1504],[1506,1510],1526,1527,[1530,1540],[1542,1573],1576,[1579,1602]],"options":{"allowJs":true,"esModuleInterop":true,"jsx":1,"module":99,"skipLibCheck":true,"strict":true,"target":4},"referencedMap":[[1594,1],[1596,2],[1595,3],[1593,4],[1597,5],[1598,6],[1599,7],[1600,8],[1592,9],[1601,10],[1602,11],[1589,12],[83,13],[1590,14],[1591,15],[511,16],[497,17],[502,18],[953,13],[954,19],[955,20],[960,21],[956,20],[959,13],[957,13],[958,13],[845,22],[807,13],[808,13],[809,13],[851,22],[846,13],[810,13],[811,13],[812,13],[813,13],[853,23],[814,13],[815,13],[816,13],[817,13],[822,24],[823,25],[824,24],[825,24],[826,13],[827,24],[828,25],[829,24],[830,24],[831,24],[832,24],[833,24],[834,25],[835,25],[836,24],[837,24],[838,25],[839,25],[840,24],[841,24],[842,13],[843,13],[852,22],[819,13],[847,13],[848,26],[849,26],[821,27],[820,28],[850,29],[844,13],[858,30],[861,31],[860,30],[859,32],[857,33],[854,13],[856,34],[855,35],[1525,36],[1524,37],[244,13],[509,38],[1505,39],[552,40],[551,41],[540,42],[539,41],[538,41],[608,43],[607,41],[548,40],[547,41],[780,44],[777,41],[550,40],[549,41],[577,45],[779,46],[778,41],[605,47],[601,48],[597,41],[599,48],[600,48],[603,49],[604,48],[598,41],[602,13],[555,50],[553,41],[557,40],[556,41],[576,41],[1575,51],[1574,41],[565,52],[564,41],[559,53],[558,41],[1529,52],[1528,41],[543,54],[759,52],[758,41],[566,55],[563,41],[1578,56],[1577,41],[611,40],[610,41],[554,13],[1405,57],[1404,13],[873,13],[1603,13],[1604,13],[1605,13],[1606,58],[1390,13],[1608,59],[1391,60],[1607,13],[1609,13],[1610,13],[1611,13],[1612,13],[143,61],[144,61],[145,62],[100,63],[146,64],[147,65],[148,66],[95,13],[98,67],[96,13],[97,13],[149,68],[150,69],[151,70],[152,71],[153,72],[154,73],[155,73],[156,74],[157,75],[158,76],[159,77],[101,13],[99,13],[160,78],[161,79],[162,80],[194,81],[163,82],[164,83],[165,84],[166,85],[167,86],[168,87],[169,88],[170,89],[171,90],[172,91],[173,91],[174,92],[175,13],[176,93],[178,94],[177,95],[179,96],[180,97],[181,98],[182,99],[183,100],[184,101],[185,102],[186,103],[187,104],[188,105],[189,106],[190,107],[191,108],[102,13],[103,13],[104,13],[142,109],[192,110],[193,111],[198,112],[354,41],[199,113],[197,114],[356,115],[355,116],[195,117],[352,13],[196,118],[84,13],[86,119],[351,41],[262,41],[1613,13],[545,120],[544,121],[529,13],[609,122],[85,13],[1049,123],[1028,124],[1125,13],[1029,125],[965,123],[966,123],[967,123],[968,123],[969,123],[970,123],[971,123],[972,123],[973,123],[974,123],[975,123],[976,123],[977,123],[978,123],[979,123],[980,123],[981,123],[982,123],[961,13],[983,123],[984,123],[985,13],[986,123],[987,123],[989,123],[988,123],[990,123],[991,123],[992,123],[993,123],[994,123],[995,123],[996,123],[997,123],[998,123],[999,123],[1000,123],[1001,123],[1002,123],[1003,123],[1004,123],[1005,123],[1006,123],[1007,123],[1008,123],[1010,123],[1011,123],[1012,123],[1009,123],[1013,123],[1014,123],[1015,123],[1016,123],[1017,123],[1018,123],[1019,123],[1020,123],[1021,123],[1022,123],[1023,123],[1024,123],[1025,123],[1026,123],[1027,123],[1030,126],[1031,123],[1032,123],[1033,127],[1034,128],[1035,123],[1036,123],[1037,123],[1038,123],[1041,123],[1039,123],[1040,123],[963,13],[1042,123],[1043,123],[1044,123],[1045,123],[1046,123],[1047,123],[1048,123],[1050,129],[1051,123],[1052,123],[1053,123],[1055,123],[1054,123],[1056,123],[1057,123],[1058,123],[1059,123],[1060,123],[1061,123],[1062,123],[1063,123],[1064,123],[1065,123],[1067,123],[1066,123],[1068,123],[1069,13],[1070,13],[1071,13],[1218,130],[1072,123],[1073,123],[1074,123],[1075,123],[1076,123],[1077,123],[1078,13],[1079,123],[1080,13],[1081,123],[1082,123],[1083,123],[1084,123],[1085,123],[1086,123],[1087,123],[1088,123],[1089,123],[1090,123],[1091,123],[1092,123],[1093,123],[1094,123],[1095,123],[1096,123],[1097,123],[1098,123],[1099,123],[1100,123],[1101,123],[1102,123],[1103,123],[1104,123],[1105,123],[1106,123],[1107,123],[1108,123],[1109,123],[1110,123],[1111,123],[1112,123],[1113,13],[1114,123],[1115,123],[1116,123],[1117,123],[1118,123],[1119,123],[1120,123],[1121,123],[1122,123],[1123,123],[1124,123],[1126,131],[1314,132],[1219,125],[1221,125],[1222,125],[1223,125],[1224,125],[1225,125],[1220,125],[1226,125],[1228,125],[1227,125],[1229,125],[1230,125],[1231,125],[1232,125],[1233,125],[1234,125],[1235,125],[1236,125],[1238,125],[1237,125],[1239,125],[1240,125],[1241,125],[1242,125],[1243,125],[1244,125],[1245,125],[1246,125],[1247,125],[1248,125],[1249,125],[1250,125],[1251,125],[1252,125],[1253,125],[1255,125],[1256,125],[1254,125],[1257,125],[1258,125],[1259,125],[1260,125],[1261,125],[1262,125],[1263,125],[1264,125],[1265,125],[1266,125],[1267,125],[1268,125],[1270,125],[1269,125],[1272,125],[1271,125],[1273,125],[1274,125],[1275,125],[1276,125],[1277,125],[1278,125],[1279,125],[1280,125],[1281,125],[1282,125],[1283,125],[1284,125],[1285,125],[1287,125],[1286,125],[1288,125],[1289,125],[1290,125],[1292,125],[1291,125],[1293,125],[1294,125],[1295,125],[1296,125],[1297,125],[1298,125],[1300,125],[1299,125],[1301,125],[1302,125],[1303,125],[1304,125],[1305,125],[962,123],[1306,125],[1307,125],[1309,125],[1308,125],[1310,125],[1311,125],[1312,125],[1313,125],[1127,123],[1128,123],[1129,13],[1130,13],[1131,13],[1132,123],[1133,13],[1134,13],[1135,13],[1136,13],[1137,13],[1138,123],[1139,123],[1140,123],[1141,123],[1142,123],[1143,123],[1144,123],[1145,123],[1150,133],[1148,134],[1149,135],[1147,136],[1146,123],[1151,123],[1152,123],[1153,123],[1154,123],[1155,123],[1156,123],[1157,123],[1158,123],[1159,123],[1160,123],[1161,13],[1162,13],[1163,123],[1164,123],[1165,13],[1166,13],[1167,13],[1168,123],[1169,123],[1170,123],[1171,123],[1172,129],[1173,123],[1174,123],[1175,123],[1176,123],[1177,123],[1178,123],[1179,123],[1180,123],[1181,123],[1182,123],[1183,123],[1184,123],[1185,123],[1186,123],[1187,123],[1188,123],[1189,123],[1190,123],[1191,123],[1192,123],[1193,123],[1194,123],[1195,123],[1196,123],[1197,123],[1198,123],[1199,123],[1200,123],[1201,123],[1202,123],[1203,123],[1204,123],[1205,123],[1206,123],[1207,123],[1208,123],[1209,123],[1210,123],[1211,123],[1212,123],[1213,123],[964,137],[1214,13],[1215,13],[1216,13],[1217,13],[1496,13],[818,13],[1401,13],[865,138],[863,139],[864,13],[862,140],[541,41],[936,141],[516,142],[515,143],[514,144],[501,145],[499,146],[500,147],[498,13],[935,148],[513,149],[512,13],[905,150],[900,151],[886,151],[902,152],[901,153],[897,152],[885,151],[898,152],[899,151],[904,154],[903,152],[934,155],[93,156],[443,157],[448,12],[450,158],[220,159],[248,160],[426,161],[243,162],[231,13],[212,13],[218,13],[416,163],[279,164],[219,13],[385,165],[253,166],[254,167],[350,168],[413,169],[368,170],[420,171],[421,172],[419,173],[418,13],[417,174],[250,175],[221,176],[300,13],[301,177],[216,13],[232,178],[222,179],[284,178],[281,178],[205,178],[246,180],[245,13],[425,181],[435,13],[211,13],[326,182],[327,183],[321,41],[471,13],[329,13],[330,184],[322,185],[477,186],[475,187],[470,13],[412,188],[411,13],[469,189],[323,41],[364,190],[362,191],[472,13],[476,13],[474,192],[473,13],[363,193],[464,194],[467,195],[291,196],[290,197],[289,198],[480,41],[288,199],[273,13],[483,13],[486,13],[485,41],[487,200],[201,13],[422,201],[423,202],[424,203],[234,13],[210,204],[200,13],[342,41],[203,205],[341,206],[340,207],[331,13],[332,13],[339,13],[334,13],[337,208],[333,13],[335,209],[338,210],[336,209],[217,13],[208,13],[209,178],[263,211],[264,212],[261,213],[259,214],[260,215],[256,13],[348,184],[370,184],[442,216],[451,217],[455,218],[429,219],[428,13],[276,13],[488,220],[438,221],[324,222],[325,223],[316,224],[306,13],[347,225],[307,226],[349,227],[344,228],[343,13],[345,13],[361,229],[430,230],[431,231],[309,232],[313,233],[304,234],[408,235],[437,236],[283,237],[386,238],[206,239],[436,240],[202,162],[257,13],[265,241],[397,242],[255,13],[396,243],[94,13],[391,244],[233,13],[302,245],[387,13],[207,13],[266,13],[395,246],[215,13],[271,247],[312,248],[427,249],[311,13],[394,13],[258,13],[399,250],[400,251],[213,13],[402,252],[404,253],[403,254],[236,13],[393,239],[406,255],[392,256],[398,257],[224,13],[227,13],[225,13],[229,13],[226,13],[228,13],[230,258],[223,13],[378,259],[377,13],[383,260],[379,261],[382,262],[381,262],[384,260],[380,261],[270,263],[371,264],[434,265],[490,13],[459,266],[461,267],[308,13],[460,268],[432,230],[489,269],[328,230],[214,13],[310,270],[267,271],[268,272],[269,273],[299,274],[407,274],[285,274],[372,275],[286,275],[252,276],[251,13],[376,277],[375,278],[374,279],[373,280],[433,281],[320,282],[358,283],[319,284],[353,285],[357,286],[415,287],[414,288],[410,289],[367,290],[369,291],[366,292],[405,293],[360,13],[447,13],[359,294],[409,13],[272,295],[305,201],[303,296],[274,297],[277,298],[484,13],[275,299],[278,299],[445,13],[444,13],[446,13],[482,13],[280,300],[318,41],[92,13],[365,301],[249,13],[238,302],[314,13],[453,41],[463,303],[298,41],[457,184],[297,304],[440,305],[296,303],[204,13],[465,306],[294,41],[295,41],[287,13],[237,13],[293,307],[292,308],[235,309],[315,90],[282,90],[401,13],[389,310],[388,13],[449,13],[346,311],[317,41],[441,312],[87,41],[90,313],[91,314],[88,41],[89,13],[247,315],[242,316],[241,13],[240,317],[239,13],[439,318],[452,319],[454,320],[456,321],[458,322],[462,323],[496,324],[466,324],[495,325],[468,326],[478,327],[479,328],[481,329],[491,330],[494,204],[493,13],[492,331],[506,332],[503,13],[504,332],[505,333],[508,334],[507,335],[1372,336],[1334,337],[1333,338],[1371,339],[1373,340],[1315,41],[1316,41],[1317,41],[1361,341],[1340,342],[1341,342],[1342,343],[1343,41],[1344,41],[1345,344],[1318,345],[1346,41],[1347,41],[1348,346],[1349,41],[1350,41],[1351,41],[1352,41],[1353,41],[1354,41],[1319,345],[1355,41],[1356,41],[1357,345],[1358,41],[1359,41],[1360,346],[1374,343],[1362,336],[1363,336],[1364,336],[1365,336],[1366,336],[1367,13],[1368,336],[1369,347],[1375,348],[1376,349],[1385,350],[1331,351],[1320,352],[1321,336],[1322,352],[1323,336],[1324,13],[1325,13],[1326,13],[1327,336],[1328,336],[1329,336],[1330,336],[1338,353],[1339,354],[1335,355],[1336,356],[1370,357],[1332,41],[1337,358],[1377,352],[1378,352],[1384,359],[1379,336],[1380,352],[1381,352],[1382,336],[1383,352],[694,13],[709,360],[710,360],[724,361],[711,362],[712,362],[713,363],[707,364],[705,365],[696,13],[700,366],[704,367],[702,368],[708,369],[697,370],[698,371],[699,372],[701,373],[703,374],[706,375],[714,362],[715,362],[716,362],[717,360],[718,362],[719,362],[695,362],[720,13],[722,376],[721,362],[723,360],[1409,13],[1418,377],[1428,378],[1474,379],[1399,380],[1445,381],[1432,382],[1492,383],[1444,384],[1429,385],[1476,386],[1475,387],[1440,388],[1431,389],[1477,390],[1478,391],[1479,392],[1487,393],[1481,393],[1489,393],[1493,393],[1480,393],[1482,393],[1485,393],[1488,393],[1484,394],[1486,393],[1490,395],[1483,395],[1394,396],[1461,41],[1458,397],[1462,41],[1454,393],[1395,393],[1452,398],[1398,399],[1411,400],[1457,401],[1460,393],[1396,41],[1459,402],[1388,41],[1387,41],[1407,41],[1500,403],[1499,404],[1501,405],[1469,13],[1467,13],[1471,406],[1470,407],[1466,408],[1468,409],[1472,410],[1473,411],[1465,41],[1415,412],[1389,393],[1464,393],[1410,413],[1463,393],[1430,412],[1491,393],[1406,414],[1449,415],[1408,416],[1433,417],[1425,418],[1434,419],[1435,420],[1436,421],[1437,422],[1441,423],[1442,424],[1417,425],[1448,426],[1446,427],[1447,428],[1443,429],[1450,430],[1419,431],[1427,432],[1413,433],[1423,434],[1424,435],[1420,436],[1414,437],[1426,438],[1393,439],[1498,13],[1412,440],[1451,441],[1494,13],[1438,13],[1455,13],[1439,13],[1497,442],[1416,443],[1421,13],[1453,444],[1456,13],[1422,13],[1495,13],[1397,41],[1403,445],[1400,13],[1402,13],[390,446],[748,41],[530,13],[81,13],[82,13],[13,13],[14,13],[16,13],[15,13],[2,13],[17,13],[18,13],[19,13],[20,13],[21,13],[22,13],[23,13],[24,13],[3,13],[25,13],[26,13],[4,13],[27,13],[31,13],[28,13],[29,13],[30,13],[32,13],[33,13],[34,13],[5,13],[35,13],[36,13],[37,13],[38,13],[6,13],[42,13],[39,13],[40,13],[41,13],[43,13],[7,13],[44,13],[49,13],[50,13],[45,13],[46,13],[47,13],[48,13],[8,13],[54,13],[51,13],[52,13],[53,13],[55,13],[9,13],[56,13],[57,13],[58,13],[60,13],[59,13],[61,13],[62,13],[10,13],[63,13],[64,13],[65,13],[11,13],[66,13],[67,13],[68,13],[69,13],[70,13],[1,13],[71,13],[72,13],[12,13],[76,13],[74,13],[79,13],[78,13],[73,13],[77,13],[75,13],[80,13],[120,447],[130,448],[119,447],[140,449],[111,450],[110,451],[139,331],[133,452],[138,453],[113,454],[127,455],[112,456],[136,457],[108,458],[107,331],[137,459],[109,460],[114,461],[115,13],[118,461],[105,13],[141,462],[131,463],[122,464],[123,465],[125,466],[121,467],[124,468],[134,331],[116,469],[117,470],[126,471],[106,472],[129,463],[128,461],[132,13],[135,473],[884,474],[803,13],[868,13],[880,475],[878,476],[806,477],[867,478],[877,479],[882,480],[874,481],[875,13],[883,482],[881,483],[872,484],[870,485],[869,13],[876,13],[866,479],[879,13],[805,13],[804,41],[871,13],[896,486],[895,487],[894,488],[887,489],[893,490],[889,151],[892,480],[890,13],[891,151],[888,491],[1541,122],[1392,492],[691,493],[1515,494],[1522,495],[1517,13],[1518,13],[1516,496],[1519,497],[1511,13],[1512,13],[1523,498],[1514,499],[1520,13],[1521,500],[1513,501],[686,502],[689,503],[687,503],[683,502],[690,504],[688,503],[684,505],[685,506],[679,507],[624,508],[626,509],[678,13],[625,510],[682,511],[680,13],[627,508],[628,13],[677,512],[623,513],[620,13],[681,514],[621,515],[622,13],[629,516],[630,516],[631,516],[632,516],[633,516],[634,516],[635,516],[636,516],[637,516],[638,516],[639,516],[640,516],[641,516],[643,516],[642,516],[644,516],[645,516],[646,516],[676,517],[647,516],[648,516],[649,516],[650,516],[651,516],[652,516],[653,516],[654,516],[655,516],[656,516],[657,516],[658,516],[659,516],[661,516],[660,516],[662,516],[663,516],[664,516],[665,516],[666,516],[667,516],[668,516],[669,516],[670,516],[671,516],[672,516],[675,516],[673,516],[674,516],[915,518],[921,519],[919,520],[917,520],[920,520],[916,520],[918,520],[914,520],[929,13],[930,521],[913,13],[928,13],[510,16],[951,522],[1504,523],[941,524],[1537,525],[1510,526],[1539,527],[1508,528],[946,529],[948,530],[1559,531],[949,532],[1562,525],[1561,526],[1563,533],[1560,534],[1564,535],[1565,536],[933,524],[938,537],[1569,538],[939,532],[940,539],[1571,540],[520,541],[521,541],[522,541],[523,541],[524,541],[525,541],[528,542],[527,542],[532,543],[534,544],[533,13],[1568,545],[1570,546],[1503,547],[1502,548],[571,549],[573,550],[562,551],[570,552],[572,553],[568,554],[561,555],[950,556],[1557,556],[770,557],[1531,558],[582,559],[583,560],[581,561],[586,562],[587,563],[580,560],[585,564],[579,560],[595,565],[594,566],[593,567],[592,568],[1538,569],[615,570],[616,571],[575,572],[617,13],[1572,573],[1509,574],[1534,575],[1535,576],[618,13],[729,577],[728,578],[1533,579],[737,580],[730,581],[736,582],[732,583],[733,584],[735,585],[734,586],[731,587],[738,588],[727,589],[726,590],[725,589],[1536,591],[693,592],[1532,593],[1507,594],[1558,595],[761,596],[746,597],[745,598],[747,599],[1553,600],[1546,601],[1540,602],[1543,603],[1556,604],[1555,604],[1552,605],[1550,606],[1545,607],[1548,608],[1547,600],[1549,609],[1554,610],[1544,611],[1551,612],[767,613],[765,614],[762,615],[763,616],[756,617],[757,616],[766,618],[764,616],[754,619],[749,620],[755,621],[750,622],[752,620],[751,620],[753,622],[768,623],[771,624],[773,625],[769,626],[772,627],[739,13],[774,13],[1527,628],[1566,629],[943,630],[776,631],[784,632],[783,633],[775,634],[782,635],[789,636],[793,637],[795,638],[792,639],[790,640],[785,555],[786,41],[794,641],[788,642],[787,643],[798,644],[797,645],[796,646],[1567,647],[1506,648],[1526,649],[596,650],[546,651],[1386,652],[537,653],[952,41],[542,654],[614,655],[613,656],[1542,657],[781,658],[1573,659],[569,543],[578,660],[947,41],[606,661],[1576,662],[560,663],[791,543],[942,664],[1530,665],[760,666],[535,543],[567,667],[584,543],[1579,668],[536,669],[612,670],[1580,41],[1581,41],[1582,41],[1583,41],[1584,41],[1585,41],[1586,41],[1587,41],[1588,41],[740,41],[744,671],[945,672],[937,41],[799,539],[800,41],[801,673],[802,41],[517,13],[906,674],[944,675],[588,13],[518,13],[907,13],[908,676],[589,13],[591,677],[909,678],[590,13],[911,679],[526,541],[743,680],[912,13],[742,681],[741,13],[531,669],[923,682],[692,683],[924,684],[519,685],[925,686],[922,687],[926,686],[927,688],[931,689],[574,13],[619,13],[910,690],[932,13]],"semanticDiagnosticsPerFile":[[560,[{"start":401,"length":5,"code":2322,"category":1,"messageText":{"messageText":"Type '{ children?: ReactNode; open?: boolean | undefined; defaultOpen?: boolean | undefined; onOpenChange?(open: boolean): void; dir?: Direction | undefined; name?: string | undefined; ... 8 more ...; modal: boolean; }' is not assignable to type 'IntrinsicAttributes & SelectSharedProps & { value?: string | undefined; defaultValue?: string | undefined; onValueChange?(value: string): void; }'.","category":1,"code":2322,"next":[{"messageText":"Property 'modal' does not exist on type 'IntrinsicAttributes & SelectSharedProps & { value?: string | undefined; defaultValue?: string | undefined; onValueChange?(value: string): void; }'.","category":1,"code":2339}]}}]],[571,[{"start":11593,"length":10,"code":2322,"category":1,"messageText":{"messageText":"Type '{} | undefined' is not assignable to type 'ReactNode'.","category":1,"code":2322,"next":[{"messageText":"Type '{}' is not assignable to type 'ReactNode'.","category":1,"code":2322}]},"relatedInformation":[{"file":"./node_modules/@types/react/index.d.ts","start":84233,"length":8,"messageText":"The expected type comes from property 'children' which is declared here on type 'DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>'","category":3,"code":6500}]}]],[573,[{"start":322,"length":9,"messageText":"Cannot find name 'DataTable'.","category":1,"code":2304}]],[692,[{"start":629,"length":4,"code":2769,"category":1,"messageText":{"messageText":"No overload matches this call.","category":1,"code":2769,"next":[{"messageText":"Overload 1 of 2, '(values: readonly [\"FG\", \"PT\", \"SM\", \"RM\", \"CS\"], params?: string | { error?: string | $ZodErrorMap<$ZodIssueInvalidValue<unknown>> | undefined; message?: string | undefined; } | undefined): ZodEnum<...>', gave the following error.","category":1,"code":2772,"next":[{"messageText":"Object literal may only specify known properties, and 'errorMap' does not exist in type '{ error?: string | $ZodErrorMap<$ZodIssueInvalidValue<unknown>> | undefined; message?: string | undefined; }'.","category":1,"code":2353}]},{"messageText":"Overload 2 of 2, '(entries: Readonly<Record<string, EnumValue>>, params?: string | { error?: string | $ZodErrorMap<$ZodIssueInvalidValue<unknown>> | undefined; message?: string | undefined; } | undefined): ZodEnum<...>', gave the following error.","category":1,"code":2772,"next":[{"messageText":"Argument of type 'string[]' is not assignable to parameter of type 'Readonly<Record<string, EnumValue>>'.","category":1,"code":2345,"next":[{"messageText":"Index signature for type 'string' is missing in type 'string[]'.","category":1,"code":2329}]}]}]},"relatedInformation":[]}]],[731,[{"start":2088,"length":11,"code":2339,"category":1,"messageText":{"messageText":"Property 'productName' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'productName' does not exist on type 'Partial<FieldErrorsImpl<{ partType: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"PT\"; length: string; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 42 more ...; finalizedBy: string; }>> & { ....'.","category":1,"code":2339}]}},{"start":2152,"length":11,"code":2339,"category":1,"messageText":{"messageText":"Property 'productName' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'productName' does not exist on type 'Partial<FieldErrorsImpl<{ partType: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"PT\"; length: string; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 42 more ...; finalizedBy: string; }>> & { ....'.","category":1,"code":2339}]}},{"start":2241,"length":11,"code":2339,"category":1,"messageText":{"messageText":"Property 'productName' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'productName' does not exist on type 'Partial<FieldErrorsImpl<{ partType: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"PT\"; length: string; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 42 more ...; finalizedBy: string; }>> & { ....'.","category":1,"code":2339}]}},{"start":2305,"length":11,"code":2339,"category":1,"messageText":{"messageText":"Property 'productName' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'productName' does not exist on type 'Partial<FieldErrorsImpl<{ partType: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"PT\"; length: string; bom: { id: string; childItemCode: string; childItemName: string; quantity: number; ... 6 more ...; bendingDetails: { ...; }[]; }[]; ... 42 more ...; finalizedBy: string; }>> & { ....'.","category":1,"code":2339}]}}]],[733,[{"start":4143,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'material' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'material' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":4640,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'material' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'material' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":4734,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'material' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'material' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":5407,"length":6,"code":2339,"category":1,"messageText":{"messageText":"Property 'length' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'length' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":5569,"length":6,"code":2339,"category":1,"messageText":{"messageText":"Property 'length' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'length' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":5661,"length":6,"code":2339,"category":1,"messageText":{"messageText":"Property 'length' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'length' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":5732,"length":6,"code":2339,"category":1,"messageText":{"messageText":"Property 'length' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'length' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":6307,"length":13,"code":2339,"category":1,"messageText":{"messageText":"Property 'bendingLength' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'bendingLength' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":7304,"length":13,"code":2339,"category":1,"messageText":{"messageText":"Property 'bendingLength' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'bendingLength' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":7403,"length":13,"code":2339,"category":1,"messageText":{"messageText":"Property 'bendingLength' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'bendingLength' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}}]],[734,[{"start":3087,"length":19,"code":2339,"category":1,"messageText":{"messageText":"Property 'electricOpenerPower' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'electricOpenerPower' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":3441,"length":19,"code":2339,"category":1,"messageText":{"messageText":"Property 'electricOpenerPower' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'electricOpenerPower' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":3546,"length":19,"code":2339,"category":1,"messageText":{"messageText":"Property 'electricOpenerPower' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'electricOpenerPower' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":4034,"length":22,"code":2339,"category":1,"messageText":{"messageText":"Property 'electricOpenerCapacity' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'electricOpenerCapacity' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":4695,"length":22,"code":2339,"category":1,"messageText":{"messageText":"Property 'electricOpenerCapacity' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'electricOpenerCapacity' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":4803,"length":22,"code":2339,"category":1,"messageText":{"messageText":"Property 'electricOpenerCapacity' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'electricOpenerCapacity' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":5544,"length":12,"code":2339,"category":1,"messageText":{"messageText":"Property 'motorVoltage' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'motorVoltage' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":5889,"length":12,"code":2339,"category":1,"messageText":{"messageText":"Property 'motorVoltage' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'motorVoltage' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":5987,"length":12,"code":2339,"category":1,"messageText":{"messageText":"Property 'motorVoltage' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'motorVoltage' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":6572,"length":9,"code":2339,"category":1,"messageText":{"messageText":"Property 'chainSpec' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'chainSpec' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":7018,"length":9,"code":2339,"category":1,"messageText":{"messageText":"Property 'chainSpec' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'chainSpec' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":7113,"length":9,"code":2339,"category":1,"messageText":{"messageText":"Property 'chainSpec' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'chainSpec' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}}]],[736,[{"start":4704,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'partType' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'partType' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":5146,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'partType' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'partType' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":5232,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'partType' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'partType' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}},{"start":5293,"length":8,"code":2339,"category":1,"messageText":{"messageText":"Property 'partType' does not exist on type 'FieldErrors<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note?: string | undefined; bom?: { id: string; childItemCode: string; ... 8 more ...; bendingDetails?: { ...; }[] | undefined; }[] | undefined; ... 21 more ...; finalizedBy?: string | un...'.","category":1,"code":2339,"next":[{"messageText":"Property 'partType' does not exist on type 'Partial<FieldErrorsImpl<{ productName: string; itemName: string; currentRevision: number; isFinal: boolean; isActive: boolean; itemType: \"FG\"; note: string; bom: { id: string; childItemCode: string; childItemName: string; ... 7 more ...; bendingDetails: { ...; }[]; }[]; ... 21 more ...; finalizedBy: string; }>> & { ...'.","category":1,"code":2339}]}}]],[764,[{"start":16745,"length":4,"code":2345,"category":1,"messageText":{"messageText":"Argument of type 'Omit<BOMItem, \"id\" | \"tenant_id\" | \"section_id\" | \"created_at\" | \"updated_at\">' is not assignable to parameter of type 'Omit<BOMItem, \"id\" | \"created_at\" | \"updated_at\">'.","category":1,"code":2345,"next":[{"messageText":"Property 'section_id' is missing in type 'Omit<BOMItem, \"id\" | \"tenant_id\" | \"section_id\" | \"created_at\" | \"updated_at\">' but required in type 'Omit<BOMItem, \"id\" | \"created_at\" | \"updated_at\">'.","category":1,"code":2741}]},"relatedInformation":[{"file":"./src/contexts/itemmastercontext.tsx","start":10037,"length":10,"messageText":"'section_id' is declared here.","category":3,"code":2728}]}]],[789,[{"start":7715,"length":3,"code":2322,"category":1,"messageText":"Type 'T' is not assignable to type 'object'.","relatedInformation":[{"start":5687,"length":1,"messageText":"This type parameter might need an `extends object` constraint.","category":1,"code":2208}]}]],[796,[{"start":3424,"length":10,"code":2322,"category":1,"messageText":{"messageText":"Type '{ title: string; subtitle?: string | undefined; icon?: ReactNode; badge?: { label: string; variant?: \"default\" | \"outline\" | \"destructive\" | \"secondary\" | undefined; } | undefined; fields: { ...; }[]; actions?: { ...; }[] | undefined; key: string; }' is not assignable to type 'MobileCardProps'.","category":1,"code":2322,"next":[{"messageText":"Types of property 'actions' are incompatible.","category":1,"code":2326,"next":[{"messageText":"Type '{ label: string; onClick: () => void; icon?: ReactNode; variant?: \"default\" | \"outline\" | \"destructive\" | undefined; }[] | undefined' is not assignable to type '{ label: string; onClick: () => void; icon?: ComponentType<any> | LucideIcon | undefined; variant?: \"default\" | \"outline\" | \"destructive\" | undefined; }[] | undefined'.","category":1,"code":2322,"next":[{"messageText":"Type '{ label: string; onClick: () => void; icon?: ReactNode; variant?: \"default\" | \"outline\" | \"destructive\" | undefined; }[]' is not assignable to type '{ label: string; onClick: () => void; icon?: ComponentType<any> | LucideIcon | undefined; variant?: \"default\" | \"outline\" | \"destructive\" | undefined; }[]'.","category":1,"code":2322,"next":[{"messageText":"Type '{ label: string; onClick: () => void; icon?: ReactNode; variant?: \"default\" | \"outline\" | \"destructive\" | undefined; }' is not assignable to type '{ label: string; onClick: () => void; icon?: ComponentType<any> | LucideIcon | undefined; variant?: \"default\" | \"outline\" | \"destructive\" | undefined; }'.","category":1,"code":2322,"next":[{"messageText":"Types of property 'icon' are incompatible.","category":1,"code":2326,"next":[{"messageText":"Type 'ReactNode' is not assignable to type 'ComponentType<any> | LucideIcon | undefined'.","category":1,"code":2322,"next":[{"messageText":"Type 'null' is not assignable to type 'ComponentType<any> | LucideIcon | undefined'.","category":1,"code":2322}],"canonicalHead":{"code":2322,"messageText":"Type '{ label: string; onClick: () => void; icon?: ReactNode; variant?: \"default\" | \"outline\" | \"destructive\" | undefined; }' is not assignable to type '{ label: string; onClick: () => void; icon?: ComponentType<any> | LucideIcon | undefined; variant?: \"default\" | \"outline\" | \"destructive\" | undefined; }'."}}]}]}]}],"canonicalHead":{"code":2322,"messageText":"Type '{ title: string; subtitle?: string | undefined; icon?: ReactNode; badge?: { label: string; variant?: \"default\" | \"outline\" | \"destructive\" | \"secondary\" | undefined; } | undefined; fields: { ...; }[]; actions?: { ...; }[] | undefined; key: string; }' is not assignable to type 'MobileCardProps'."}}]}]}}]],[797,[{"start":4605,"length":11,"code":2322,"category":1,"messageText":{"messageText":"Type '{ children: (false | Element | undefined)[]; devMetadata: DevMetadata | undefined; }' is not assignable to type 'IntrinsicAttributes & PageLayoutProps'.","category":1,"code":2322,"next":[{"messageText":"Property 'devMetadata' does not exist on type 'IntrinsicAttributes & PageLayoutProps'.","category":1,"code":2339}]}}]],[801,[{"start":3668,"length":8,"code":2322,"category":1,"messageText":"Type 'string' is not assignable to type 'ItemType'.","relatedInformation":[{"file":"./src/types/item.ts","start":2640,"length":8,"messageText":"The expected type comes from property 'itemType' which is declared here on type 'ItemMaster'","category":3,"code":6500}]},{"start":3734,"length":8,"code":2322,"category":1,"messageText":{"messageText":"Type 'string | undefined' is not assignable to type 'PartType | undefined'.","category":1,"code":2322,"next":[{"messageText":"Type 'string' is not assignable to type 'PartType | undefined'.","category":1,"code":2322}]},"relatedInformation":[{"file":"./src/types/item.ts","start":3688,"length":8,"messageText":"The expected type comes from property 'partType' which is declared here on type 'ItemMaster'","category":3,"code":6500}]}]],[911,[{"start":821,"length":24,"code":7053,"category":1,"messageText":{"messageText":"Element implicitly has an 'any' type because expression of type '\"Authorization\"' can't be used to index type 'HeadersInit'.","category":1,"code":7053,"next":[{"messageText":"Property 'Authorization' does not exist on type 'HeadersInit'.","category":1,"code":2339}]}}]],[931,[{"start":7708,"length":11,"code":2769,"category":1,"messageText":{"messageText":"No overload matches this call.","category":1,"code":2769,"next":[{"messageText":"Overload 1 of 2, '(partial: MasterDataStore | Partial<MasterDataStore> | ((state: MasterDataStore) => MasterDataStore | Partial<...>), replace?: false | undefined, action?: Action | undefined): void', gave the following error.","category":1,"code":2772,"next":[{"messageText":"Type '{}' is missing the following properties from type 'Record<PageType, PageConfig | null>': \"item-master\", quotation, \"sales-order\", formula, pricing","category":1,"code":2739,"canonicalHead":{"code":2322,"messageText":"Type '{}' is not assignable to type 'Record<PageType, PageConfig | null>'."}}]},{"messageText":"Overload 2 of 2, '(state: MasterDataStore | ((state: MasterDataStore) => MasterDataStore), replace: true, action?: Action | undefined): void', gave the following error.","category":1,"code":2772,"next":[{"messageText":"Type '{}' is missing the following properties from type 'Record<PageType, PageConfig | null>': \"item-master\", quotation, \"sales-order\", formula, pricing","category":1,"code":2739,"canonicalHead":{"code":2322,"messageText":"Type '{}' is not assignable to type 'Record<PageType, PageConfig | null>'."}}]}]},"relatedInformation":[]},{"start":10569,"length":7,"messageText":"Expected 0-1 arguments, but got 2.","category":1,"code":2554}]],[1507,[{"start":1092,"length":39,"messageText":"Cannot find module '@/components/molecules/ListMobileCard' or its corresponding type declarations.","category":1,"code":2307},{"start":1159,"length":30,"messageText":"Cannot find module '@/components/atoms/InfoField' or its corresponding type declarations.","category":1,"code":2307}]],[1538,[{"start":36033,"length":10,"code":2322,"category":1,"messageText":{"messageText":"Type '{ part_type?: string | undefined; bending_diagram?: string | null | undefined; bending_details?: BendingDetail[] | null | undefined; width_sum?: string | null | undefined; ... 4 more ...; bom: { ...; }[]; }' is not assignable to type 'DynamicFormData'.","category":1,"code":2322,"next":[{"messageText":"Property 'bending_details' is incompatible with index signature.","category":1,"code":2530,"next":[{"messageText":"Type 'BendingDetail[] | null' is not assignable to type 'DynamicFieldValue'.","category":1,"code":2322,"next":[{"messageText":"Type 'BendingDetail[]' is not assignable to type 'DynamicFieldValue'.","category":1,"code":2322,"next":[{"messageText":"Type 'BendingDetail[]' is not assignable to type 'Record<string, unknown>[]'.","category":1,"code":2322,"next":[{"messageText":"Type 'BendingDetail' is not assignable to type 'Record<string, unknown>'.","category":1,"code":2322,"next":[{"messageText":"Index signature for type 'string' is missing in type 'BendingDetail'.","category":1,"code":2329}]}]}]}]}]}]}},{"start":48145,"length":5,"code":2345,"category":1,"messageText":{"messageText":"Argument of type 'string | number | boolean | string[] | { id: string; no: number; input: number; elongation: number; calculated: number; sum: number; shaded: boolean; aAngle?: number | undefined; } | { id: string; ... 6 more ...; aAngle?: number | undefined; }[] | { ...; } | { ...; }[] | null | undefined' is not assignable to parameter of type 'DynamicFieldValue'.","category":1,"code":2345,"next":[{"messageText":"Type 'string[]' is not assignable to type 'DynamicFieldValue'.","category":1,"code":2322,"next":[{"messageText":"Type 'string[]' is not assignable to type 'Record<string, unknown>[]'.","category":1,"code":2322,"next":[{"messageText":"Type 'string' is not assignable to type 'Record<string, unknown>'.","category":1,"code":2322}]}]}]}},{"start":48883,"length":5,"code":2345,"category":1,"messageText":{"messageText":"Argument of type 'string | number | boolean | string[] | { id: string; no: number; input: number; elongation: number; calculated: number; sum: number; shaded: boolean; aAngle?: number | undefined; } | { id: string; ... 6 more ...; aAngle?: number | undefined; }[] | { ...; } | { ...; }[] | null | undefined' is not assignable to parameter of type 'DynamicFieldValue'.","category":1,"code":2345,"next":[{"messageText":"Type 'string[]' is not assignable to type 'DynamicFieldValue'.","category":1,"code":2322,"next":[{"messageText":"Type 'string[]' is not assignable to type 'Record<string, unknown>[]'.","category":1,"code":2322,"next":[{"messageText":"Type 'string' is not assignable to type 'Record<string, unknown>'.","category":1,"code":2322}]}]}]}}]],[1539,[{"start":1585,"length":15,"code":2741,"category":1,"messageText":"Property 'itemType' is missing in type '{ mode: \"create\"; onSubmit: (data: DynamicFormData) => Promise<void>; }' but required in type 'DynamicItemFormProps'.","relatedInformation":[{"file":"./src/components/items/dynamicitemform/types.ts","start":2719,"length":8,"messageText":"'itemType' is declared here.","category":3,"code":2728}],"canonicalHead":{"code":2322,"messageText":"Type '{ mode: \"create\"; onSubmit: (data: DynamicFormData) => Promise<void>; }' is not assignable to type 'DynamicItemFormProps'."}}]],[1560,[{"start":3253,"length":5,"code":2322,"category":1,"messageText":{"messageText":"Type '{ items: ItemMaster[]; }' is not assignable to type 'IntrinsicAttributes'.","category":1,"code":2322,"next":[{"messageText":"Property 'items' does not exist on type 'IntrinsicAttributes'.","category":1,"code":2339}]}}]],[1564,[{"start":16797,"length":25,"code":2322,"category":1,"messageText":{"messageText":"Type 'RefObject<HTMLDivElement | null>' is not assignable to type 'RefObject<HTMLDivElement>'.","category":1,"code":2322,"next":[{"messageText":"Type 'HTMLDivElement | null' is not assignable to type 'HTMLDivElement'.","category":1,"code":2322,"next":[{"messageText":"Type 'null' is not assignable to type 'HTMLDivElement'.","category":1,"code":2322}]}]},"relatedInformation":[{"file":"./src/components/templates/integratedlisttemplatev2.tsx","start":2921,"length":25,"messageText":"The expected type comes from property 'infinityScrollSentinelRef' which is declared here on type 'IntrinsicAttributes & IntegratedListTemplateV2Props<CustomerAccount>'","category":3,"code":6500}]}]],[1565,[{"start":18966,"length":5,"code":2322,"category":1,"messageText":{"messageText":"Type '{ label: string; value: string; icon: ForwardRefExoticComponent<Omit<LucideProps, \"ref\"> & RefAttributes<SVGSVGElement>>; iconColor: string; }[]' is not assignable to type 'StatCard[]'.","category":1,"code":2322,"next":[{"messageText":"Type '{ label: string; value: string; icon: ForwardRefExoticComponent<Omit<LucideProps, \"ref\"> & RefAttributes<SVGSVGElement>>; iconColor: string; }' is not assignable to type 'StatCard'.","category":1,"code":2322,"next":[{"messageText":"Types of property 'value' are incompatible.","category":1,"code":2326,"next":[{"messageText":"Type 'string' is not assignable to type 'number'.","category":1,"code":2322,"canonicalHead":{"code":2322,"messageText":"Type '{ label: string; value: string; icon: ForwardRefExoticComponent<Omit<LucideProps, \"ref\"> & RefAttributes<SVGSVGElement>>; iconColor: string; }' is not assignable to type 'StatCard'."}}]}]}]},"relatedInformation":[{"file":"./src/components/templates/integratedlisttemplatev2.tsx","start":2226,"length":5,"messageText":"The expected type comes from property 'stats' which is declared here on type 'IntrinsicAttributes & IntegratedListTemplateV2Props<Quote>'","category":3,"code":6500}]},{"start":19581,"length":25,"code":2322,"category":1,"messageText":{"messageText":"Type 'RefObject<HTMLDivElement | null>' is not assignable to type 'RefObject<HTMLDivElement>'.","category":1,"code":2322,"next":[{"messageText":"Type 'HTMLDivElement | null' is not assignable to type 'HTMLDivElement'.","category":1,"code":2322,"next":[{"messageText":"Type 'null' is not assignable to type 'HTMLDivElement'.","category":1,"code":2322}]}]},"relatedInformation":[{"file":"./src/components/templates/integratedlisttemplatev2.tsx","start":2921,"length":25,"messageText":"The expected type comes from property 'infinityScrollSentinelRef' which is declared here on type 'IntrinsicAttributes & IntegratedListTemplateV2Props<Quote>'","category":3,"code":6500}]}]]],"affectedFilesPendingEmit":[1594,1596,1595,1593,1597,1598,1599,1600,1592,1601,1602,1591,511,502,510,951,1504,941,1537,1510,1539,1508,946,948,1559,949,1562,1561,1563,1560,1564,1565,933,938,1569,939,940,1571,520,521,522,523,524,525,528,527,532,534,533,1568,1570,1503,1502,571,573,562,570,572,568,561,950,1557,770,1531,582,583,581,586,587,580,585,579,595,594,593,592,1538,615,616,575,617,1572,1509,1534,1535,618,729,728,1533,737,730,736,732,733,735,734,731,738,727,726,725,1536,693,1532,1507,1558,761,746,745,747,1553,1546,1540,1543,1556,1555,1552,1550,1545,1548,1547,1549,1554,1544,1551,767,765,762,763,756,757,766,764,754,749,755,750,752,751,753,768,771,773,769,772,739,774,1527,1566,943,776,784,783,775,782,789,793,795,792,790,785,786,794,788,787,798,797,796,1567,1506,1526,596,546,1386,537,952,542,614,613,1542,781,1573,569,578,947,606,1576,560,791,942,1530,760,535,567,584,1579,536,612,1580,1581,1582,1583,1584,1585,1586,1587,1588,740,744,945,937,799,800,801,802,517,906,944,588,518,907,908,589,591,909,590,911,526,743,912,742,741,531,923,692,924,519,925,922,926,927,931,574,619,910,932],"version":"5.9.3"}
\ No newline at end of file