cc-transcript 14.31.0__tar.gz → 14.32.0__tar.gz

{cc_transcript-14.31.0 → cc_transcript-14.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 14.31.0
+Version: 14.32.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{cc_transcript-14.31.0 → cc_transcript-14.32.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.31.0" # informational — releases stamp the version from the git tag
+version = "14.32.0" # informational — releases stamp the version from the git tag
 description = "Grep every Claude Code session you've ever run."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"

{cc_transcript-14.31.0 → cc_transcript-14.32.0}/rust/crates/core/src/snapshot.rs

@@ -423,6 +423,7 @@ struct Waiter {
     used_source_bytes: usize,
     used_events: usize,
     stage: Option<Arc<ClassifierSlot>>,
+    windowed: bool,
     busy: bool,
 }
 
@@ -688,7 +689,7 @@ struct PreparedQueryCursor {
     graph_id: String,
     query: Value,
     pending: Option<PendingPreparedSource>,
-    root_record: Option<String>,
+    input_records: Option<VecDeque<String>>,
     next: usize,
     page_output_bytes: usize,
     remaining: WorkLimits,
@@ -763,7 +764,7 @@ struct GraphCursor {
     prepared: bool,
     root_checked: bool,
     projection_at: usize,
-    pending_record: Option<(usize, String)>,
+    pending_records: VecDeque<(usize, String)>,
     published_members: Vec<usize>,
     expires: u64,
     accounted: usize,
@@ -2507,7 +2508,10 @@ impl NativeStore {
                 .values()
                 .map(|cursor| {
                     size_of::<PreparedQueryCursor>()
-                        + cursor.root_record.as_ref().map_or(0, String::capacity)
+                        + cursor
+                            .input_records
+                            .as_ref()
+                            .map_or(0, |records| records.iter().map(String::capacity).sum())
                         + crate::snapshot_memory::value_charge(&cursor.query).owned_capacity_bytes
                 })
                 .sum::<usize>()
@@ -4154,6 +4158,7 @@ impl NativeStore {
                 used_source_bytes: 0,
                 used_events: 0,
                 stage: None,
+                windowed: window.is_some(),
                 busy: false,
             };
             state.waiters.insert(cursor.clone(), waiter.clone());
@@ -4409,6 +4414,14 @@ impl NativeStore {
         if let Some(snapshot) = &load.result {
             let snapshot = Arc::clone(snapshot);
             drop(load);
+            if waiter.windowed && snapshot.provider == Provider::Codex {
+                self.state
+                    .lock()
+                    .expect("snapshot state")
+                    .waiters
+                    .remove(token);
+                return Err(invalid("tail_bytes requires a Claude source"));
+            }
             let mut state = self.state.lock().expect("snapshot state");
             if !state
                 .latest
@@ -5039,7 +5052,7 @@ impl NativeStore {
                 depth: 1,
             });
         }
-        let identity = root.stamp.identity;
+        let identity = root.stamp.identity.file();
         let graph = GraphCursor {
             claimant: str_field(context, "claimant")?.to_owned(),
             context: context.clone(),
@@ -5061,7 +5074,7 @@ impl NativeStore {
             prepared: false,
             root_checked: false,
             projection_at: 0,
-            pending_record: None,
+            pending_records: VecDeque::new(),
             published_members: Vec::new(),
             expires: (now_ms() + self.config.ttl).min(bounds.deadline_unix_ms),
             accounted: 0,
@@ -5142,9 +5155,10 @@ impl NativeStore {
                     .sum::<usize>()
                 + graph.tasks.capacity() * size_of::<GraphTask>()
                 + graph
-                    .pending_record
-                    .as_ref()
-                    .map_or(0, |(_, record)| record.capacity())
+                    .pending_records
+                    .iter()
+                    .map(|(_, record)| record.capacity())
+                    .sum::<usize>()
                 + graph.listing.as_ref().map_or(0, |listing| {
                     listing
                         .children
@@ -5199,7 +5213,7 @@ impl NativeStore {
             &graph.context,
             graph.remaining.deadline_unix_ms,
         )?;
-        let identity = snapshot.stamp.identity;
+        let identity = snapshot.stamp.identity.file();
         if !graph.seen.insert(identity)
             && graph.request["query"]["kind"].as_str() != Some("direct_sidechains")
         {
@@ -5556,7 +5570,7 @@ impl NativeStore {
         let mut output_bytes = 128usize;
         let page_limit = self.config.page_items.min(graph.remaining.max_items);
         let mut projected = 0usize;
-        while graph.projection_at < total || graph.pending_record.is_some() {
+        while graph.projection_at < total || !graph.pending_records.is_empty() {
             cancel.check(graph.remaining.deadline_unix_ms)?;
             if boolean && projected >= self.config.page_items {
                 return Ok(GraphYield::Pending(Value::new_null()));
@@ -5564,7 +5578,7 @@ impl NativeStore {
             if records.len() >= page_limit {
                 break;
             }
-            let (index, record) = if let Some(pending) = graph.pending_record.take() {
+            let (index, record) = if let Some(pending) = graph.pending_records.pop_front() {
                 pending
             } else {
                 let position = if reverse {
@@ -5597,27 +5611,27 @@ impl NativeStore {
                     let mut bounds = graph.remaining;
                     bounds.max_items = 1;
                     bounds.max_output_bytes = bounds.max_output_bytes.min(MAX_DATA_BYTES);
-                    let projection = crate::snapshot_projection::project(
-                        &node.snapshot,
-                        &request,
-                        &bounds,
-                        cancel,
-                        0,
-                    )?;
-                    graph.remaining.max_read_bytes = graph
-                        .remaining
-                        .max_read_bytes
-                        .saturating_sub(projection.read_bytes);
-                    graph.remaining.max_events =
-                        graph.remaining.max_events.saturating_sub(projection.events);
-                    if !projection.complete {
-                        return Err(SnapshotError::new(
-                            Status::Incomplete,
-                            "graph member projection incomplete",
-                        ));
-                    }
-                    graph.projection_at += 1;
                     if boolean {
+                        let projection = crate::snapshot_projection::project(
+                            &node.snapshot,
+                            &request,
+                            &bounds,
+                            cancel,
+                            0,
+                        )?;
+                        graph.remaining.max_read_bytes = graph
+                            .remaining
+                            .max_read_bytes
+                            .saturating_sub(projection.read_bytes);
+                        graph.remaining.max_events =
+                            graph.remaining.max_events.saturating_sub(projection.events);
+                        if !projection.complete {
+                            return Err(SnapshotError::new(
+                                Status::Incomplete,
+                                "graph member projection incomplete",
+                            ));
+                        }
+                        graph.projection_at += 1;
                         projected += 1;
                         if projection.data["value"].as_bool() == Some(true) {
                             return Ok(GraphYield::Complete(projection.data));
@@ -5627,20 +5641,29 @@ impl NativeStore {
                         }
                         continue;
                     }
-                    (
-                        index,
-                        projection.data["records_json"][0]
-                            .as_str()
-                            .ok_or_else(|| invalid("predicate member returned no record"))?
-                            .to_owned(),
-                    )
+                    let (member_records, read_bytes, events) =
+                        crate::snapshot_projection::predicate_input_records(
+                            &node.snapshot,
+                            &request["view"]["selectors"],
+                            &bounds,
+                            cancel,
+                        )?;
+                    graph.remaining.max_read_bytes =
+                        graph.remaining.max_read_bytes.saturating_sub(read_bytes);
+                    graph.remaining.max_events = graph.remaining.max_events.saturating_sub(events);
+                    graph.projection_at += 1;
+                    let mut member_records =
+                        member_records.into_iter().map(|record| (index, record));
+                    let first = member_records.next().expect("predicate member record");
+                    graph.pending_records.extend(member_records);
+                    first
                 }
             };
             let record_bytes = encoded_size(&json!(&record), MAX_DATA_BYTES)?;
             if output_bytes.saturating_add(record_bytes)
                 > graph.remaining.max_output_bytes.min(MAX_DATA_BYTES)
             {
-                graph.pending_record = Some((index, record));
+                graph.pending_records.push_front((index, record));
                 if records.is_empty() {
                     return Err(SnapshotError::new(
                         Status::OutputLimit,
@@ -5664,7 +5687,7 @@ impl NativeStore {
             .remaining
             .max_items
             .saturating_sub(data["records_json"].as_array().expect("records").len());
-        if graph.projection_at >= total && graph.pending_record.is_none() {
+        if graph.projection_at >= total && graph.pending_records.is_empty() {
             Ok(GraphYield::Complete(data))
         } else if graph.remaining.max_items == 0 {
             Err(SnapshotError::new(
@@ -8235,6 +8258,64 @@ mod tests {
             &Cancellation::default(),
         );
         assert_eq!(zero["status"].as_str(), Some("invalid_request"));
+        let size = std::fs::metadata(&codex.path).unwrap().len();
+        for tail_bytes in [size, size - 1, 1024 * 1024] {
+            let covered = finish(
+                &store,
+                store.request(
+                    &windowed_acquire(&codex.path, tail_bytes),
+                    &owner,
+                    &Cancellation::default(),
+                ),
+                &owner,
+            );
+            assert_eq!(
+                covered["reason"].as_str(),
+                Some("tail_bytes requires a Claude source"),
+                "{tail_bytes}: {covered:?}"
+            );
+        }
+        let whole = finish(
+            &store,
+            store.request(&acquire(&codex.path), &owner, &Cancellation::default()),
+            &owner,
+        );
+        assert_eq!(whole["status"].as_str(), Some("ok"), "{whole:?}");
+        let cached = finish(
+            &store,
+            store.request(
+                &windowed_acquire(&codex.path, 1024 * 1024),
+                &owner,
+                &Cancellation::default(),
+            ),
+            &owner,
+        );
+        assert_eq!(cached["status"].as_str(), Some("invalid_request"));
+        assert_eq!(
+            cached["reason"].as_str(),
+            Some("tail_bytes requires a Claude source")
+        );
+    }
+
+    #[test]
+    fn windowed_root_attached_to_itself_is_not_its_own_child() {
+        let source = Source::new(&users(0..200));
+        let store = windowed_store();
+        let owner = context("a");
+        let root = windowed(&store, &source.path, 4096, &owner);
+        let (_, _, first) = expected_window(&source.path, 4096);
+        assert!(first > 0);
+        let records = graph_records(
+            &store,
+            &graph_request(
+                &root,
+                json!({"kind":"sidechain_membership","order":"forward"}),
+                vec![source.path.to_string_lossy().into_owned()],
+                json!([]),
+            ),
+            &owner,
+        );
+        assert!(records.is_empty(), "{records:?}");
     }
 
     #[test]
@@ -9183,6 +9264,78 @@ mod tests {
         assert_eq!(after[15], after_first[15]);
     }
 
+    #[test]
+    fn deep_predicate_inputs_split_a_window_over_the_record_bound() {
+        let commands: Vec<String> = (0..48)
+            .map(|index| format!("echo {index:02} {}", "x".repeat(32 * 1024)))
+            .collect();
+        let tools: String = commands
+            .iter()
+            .enumerate()
+            .map(|(index, command)| format!(
+                "{}\n",
+                format_args!(r#"{{"type":"assistant","uuid":"tool-{index}","sessionId":"s","timestamp":"2026-01-02T03:04:06Z","message":{{"model":"test","content":[{{"type":"tool_use","id":"bash-{index}","name":"Bash","input":{{"command":"{command}"}}}}]}}}}"#)
+            ))
+            .collect();
+        let source = Source::new(&format!("{}\n{tools}", user("root")));
+        let store = NativeStore::new(&json!({"max_read_bytes_per_step":4*1024*1024,"max_events_per_step":256,"max_entry_bytes":64*1024,"max_retained_bytes":64*1024*1024,"reserved_hook_accounted_bytes":4096,"max_leases":16,"reserved_hook_leases":1})).unwrap();
+        let owner = context("a");
+        let mut template = acquire(&source.path);
+        template["limits"].insert("max_read_bytes", json!(64 * 1024 * 1024));
+        template["limits"].insert("max_source_read_bytes", json!(64 * 1024 * 1024));
+        template["limits"].insert("max_output_bytes", json!(16 * 1024 * 1024));
+        let root = finish(
+            &store,
+            store.request(&template, &owner, &Cancellation::default()),
+            &owner,
+        );
+        let commands_of = |records: &[String]| -> Vec<String> {
+            assert!(records.len() > 1, "{} records", records.len());
+            for record in records {
+                assert!(record.len() <= crate::snapshot_codec::MAX_RECORD_BYTES);
+            }
+            crate::snapshot_codec::decode_predicate_inputs(
+                records,
+                crate::snapshot_codec::MAX_PAGE_BYTES,
+            )
+            .unwrap()
+            .into_iter()
+            .flat_map(|record| record.commands)
+            .collect()
+        };
+        let pages = |mut page: Value| -> Vec<String> {
+            let mut records = Vec::new();
+            for _ in 0..64 {
+                records.extend(
+                    page["data"]["records_json"]
+                        .as_array()
+                        .unwrap_or_else(|| panic!("{page:?}"))
+                        .iter()
+                        .map(|item| item.as_str().unwrap().to_owned()),
+                );
+                if page["status"].as_str() == Some("ok") {
+                    return records;
+                }
+                assert_eq!(page["status"].as_str(), Some("incomplete"), "{page:?}");
+                page = store.request(&json!({"schema":SCHEMA,"id":"resume","operation":"resume","cursor":page["cursor"]}), &owner, &Cancellation::default());
+            }
+            panic!("deep predicate inputs did not finish");
+        };
+        let mut query = graph_request(
+            &root,
+            json!({"kind":"deep_predicate_inputs","order":"forward"}),
+            Vec::new(),
+            json!([]),
+        );
+        query["limits"] = template["limits"].clone();
+        let lease = pages(store.request(&query, &owner, &Cancellation::default()));
+        assert_eq!(commands_of(&lease), commands);
+        let prepare = finish_prepared(&store, store.request(&json!({"schema":SCHEMA,"id":"prepare","operation":"prepare_graph","view":{"handle":handle(&root),"classifier":{"id":"native","version":"1"},"selectors":[],"attachments":[]},"thread_ids":[],"roots":[],"direct_paths":[],"deadline_unix_ms":template["deadline_unix_ms"],"limits":template["limits"]}), &owner, &Cancellation::default()), &owner);
+        assert_eq!(prepare["status"].as_str(), Some("ok"), "{prepare:?}");
+        let prepared = pages(store.request(&json!({"schema":SCHEMA,"id":"inputs","operation":"query_graph","handle":prepare["data"]["handle"],"selectors":[],"query":{"kind":"deep_predicate_inputs","order":"forward"},"deadline_unix_ms":template["deadline_unix_ms"],"limits":template["limits"]}), &owner, &Cancellation::default()));
+        assert_eq!(commands_of(&prepared), commands);
+    }
+
     #[test]
     fn expired_prepared_query_reports_deadline_after_pruning() {
         let source = Source::new(&format!("{}\n", user("root")));

{cc_transcript-14.31.0 → cc_transcript-14.32.0}/rust/crates/core/src/snapshot_codec.rs

@@ -144,6 +144,48 @@ pub struct PredicateInputsRecord {
     pub skills: Vec<String>,
 }
 
+pub const PREDICATE_INPUT_CHUNK_BYTES: usize = 256 * 1024;
+
+pub fn predicate_input_records(inputs: &sonic_rs::Value) -> Result<Vec<String>, SnapshotError> {
+    use sonic_rs::JsonContainerTrait;
+
+    let mut records = Vec::new();
+    let mut fields: [Vec<String>; 4] = Default::default();
+    let mut bytes = 0usize;
+    for (slot, name) in ["calls", "commands", "edited_files", "skills"]
+        .into_iter()
+        .enumerate()
+    {
+        for item in inputs[name]
+            .as_array()
+            .expect("predicate input field")
+            .iter()
+        {
+            let item = encode(item, MAX_RECORD_BYTES)?;
+            let cost = encoded_size(item.as_str(), MAX_RECORD_BYTES)? + 1;
+            if bytes > 0 && bytes + cost > PREDICATE_INPUT_CHUNK_BYTES {
+                records.push(predicate_input_record(&fields));
+                fields = Default::default();
+                bytes = 0;
+            }
+            bytes += cost;
+            fields[slot].push(item);
+        }
+    }
+    records.push(predicate_input_record(&fields));
+    Ok(records)
+}
+
+fn predicate_input_record([calls, commands, edited_files, skills]: &[Vec<String>; 4]) -> String {
+    format!(
+        r#"{{"calls":[{}],"commands":[{}],"edited_files":[{}],"skills":[{}]}}"#,
+        calls.join(","),
+        commands.join(","),
+        edited_files.join(","),
+        skills.join(",")
+    )
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct SidechainRecord {

{cc_transcript-14.31.0 → cc_transcript-14.32.0}/rust/crates/core/src/snapshot_labels.rs

@@ -470,7 +470,7 @@ impl LabelPreparation {
             session_id: self.source.session_id.clone(),
             chunks: self.source.chunks.clone(),
             activity: Arc::new(self.activity),
-            window_start: 0,
+            window_start: self.source.window_start,
             committed_bytes: self.source.committed_bytes,
             provisional_tail: self.source.provisional_tail,
             fence: self.source.fence.clone(),
@@ -1042,4 +1042,26 @@ mod tests {
             "labels:execution"
         );
     }
+
+    #[test]
+    fn finish_keeps_the_source_window_start() {
+        let mut snapshot = source(vec![user(0, "prompt"), user(1, "later")]);
+        {
+            let windowed = Arc::get_mut(&mut snapshot).unwrap();
+            windowed.window_start = 1000;
+            windowed.stamp.identity.window_base = 1024;
+        }
+        let binding = binding("execution");
+        let cancel = Cancellation::default();
+        let mut stage =
+            LabelPreparation::new(snapshot, binding.clone(), limits(), 8 * PAGE_BYTES, None)
+                .unwrap();
+        stage.next_page("page1".into(), &binding, &cancel).unwrap();
+        assert!(stage
+            .submit("page1", &[true, false], &binding, &cancel)
+            .unwrap());
+        let derived = stage.finish(&binding, &cancel).unwrap().0;
+        assert_eq!(derived.window_start, 1000);
+        assert_eq!(derived.stamp.identity.window_base, 1024);
+    }
 }

{cc_transcript-14.31.0 → cc_transcript-14.32.0}/rust/crates/core/src/snapshot_prepared_service.rs

@@ -1465,8 +1465,8 @@ impl NativeStore {
             }
             (graph.sources.clone(), graph.sidechain_dirs.clone())
         };
-        let inputs = cursor.root_record.is_some();
-        let total = sources.len() + usize::from(inputs);
+        let inputs = cursor.input_records.is_some();
+        let total = sources.len();
         let mut records = Vec::new();
         let mut bytes = 128usize;
         let mut steps = 0usize;
@@ -1483,27 +1483,30 @@ impl NativeStore {
                 "prepared query output budget exhausted",
             ));
         }
-        while cursor.next < total
+        while (cursor.next < total
+            || cursor.input_records.as_ref().is_some_and(|records| !records.is_empty()))
             && steps < page_steps
             && uncached_steps < 8
             && (!inputs || records.len() < page_items)
         {
             cancel.check(cursor.remaining.deadline_unix_ms)?;
-            if inputs && cursor.next == 0 {
-                let record = cursor.root_record.as_ref().expect("input root record").clone();
+            if let Some(record) = cursor.input_records.as_mut().and_then(VecDeque::pop_front) {
                 let record_bytes = encoded_size(&json!(&record), MAX_DATA_BYTES)? + 1;
                 if bytes + record_bytes > output_limit {
-                    return Err(SnapshotError::new(
-                        Status::OutputLimit,
-                        "prepared input record exceeds page bound",
-                    ));
+                    if records.is_empty() {
+                        return Err(SnapshotError::new(
+                            Status::OutputLimit,
+                            "prepared input record exceeds page bound",
+                        ));
+                    }
+                    cursor.input_records.as_mut().expect("input records").push_front(record);
+                    break;
                 }
                 bytes += record_bytes;
                 records.push(record);
-                cursor.next += 1;
                 continue;
             }
-            let source = &sources[cursor.next - usize::from(inputs)];
+            let source = &sources[cursor.next];
             self.authority(context, Some(&source.path))?;
             let metadata = std::fs::metadata(&source.path).map_err(io_error)?;
             if SourceStamp::of(&metadata) != source.stamp {
@@ -1576,20 +1579,11 @@ impl NativeStore {
                 ));
             }
             if inputs {
-                let record = sonic_rs::to_string(&facts.inputs)
-                    .map_err(|error| invalid(error.to_string()))?;
-                let record_bytes = encoded_size(&json!(&record), MAX_DATA_BYTES)? + 1;
-                if bytes + record_bytes > output_limit {
-                    if records.is_empty() {
-                        return Err(SnapshotError::new(
-                            Status::OutputLimit,
-                            "prepared input record exceeds page bound",
-                        ));
-                    }
-                    break;
-                }
-                bytes += record_bytes;
-                records.push(record);
+                cursor
+                    .input_records
+                    .as_mut()
+                    .expect("input records")
+                    .extend(crate::snapshot_codec::predicate_input_records(&facts.inputs)?);
             } else if facts.query(&cursor.query)?["value"].as_bool() == Some(true) {
                 let data = json!({"kind":"scalar","value":true});
                 encoded_size(&data, output_limit)?;
@@ -1599,7 +1593,9 @@ impl NativeStore {
             steps += 1;
             uncached_steps += usize::from(!cached);
         }
-        if cursor.next == total {
+        if cursor.next == total
+            && cursor.input_records.as_ref().is_none_or(VecDeque::is_empty)
+        {
             if !self.validate_source_stamps(
                 &sources,
                 context,
@@ -1781,8 +1777,10 @@ impl NativeStore {
             encoded_size(&data, bounds.max_output_bytes)?;
             return Ok((data, None, None));
         }
-        let root_record = if kind == "deep_predicate_inputs" {
-            Some(sonic_rs::to_string(&root_facts.inputs).map_err(|error| invalid(error.to_string()))?)
+        let input_records = if kind == "deep_predicate_inputs" {
+            Some(VecDeque::from(crate::snapshot_codec::predicate_input_records(
+                &root_facts.inputs,
+            )?))
         } else {
             None
         };
@@ -1791,7 +1789,7 @@ impl NativeStore {
             graph_id: token.to_owned(),
             query: query.clone(),
             pending: None,
-            root_record,
+            input_records,
             next: 0,
             page_output_bytes: bounds.max_output_bytes.min(MAX_DATA_BYTES),
             remaining: bounds,

{cc_transcript-14.31.0 → cc_transcript-14.32.0}/rust/crates/core/src/snapshot_projection.rs

@@ -1456,6 +1456,31 @@ fn predicate_inputs_query(
     next: usize,
     work: &Work,
 ) -> Result<Projection, SnapshotError> {
+    record_page(
+        predicate_records(session)?.into_iter().map(Ok),
+        "cc-transcript.predicate-inputs/1",
+        next,
+        false,
+        work,
+    )
+}
+
+pub fn predicate_input_records(
+    snapshot: &TranscriptSnapshot,
+    selectors: &Value,
+    limits: &WorkLimits,
+    cancel: &Cancellation,
+) -> Result<(Vec<String>, usize, usize), SnapshotError> {
+    let request = json!({"view":{"attachments":[],"selectors":selectors}});
+    let mut work = Work::new(snapshot, limits, cancel);
+    let range = selected_range(&mut work, &request)?;
+    work.charge_range(range.clone())?;
+    let lift = lift_range(&mut work, &range, None)?;
+    let records = predicate_records(&view(&lift, &range, snapshot))?;
+    Ok((records, work.bytes, work.events))
+}
+
+fn predicate_records(session: &Session) -> Result<Vec<String>, SnapshotError> {
     let calls = session.tool_calls().items();
     let wire = PredicateInputWire {
         calls: calls
@@ -1482,12 +1507,8 @@ fn predicate_inputs_query(
             })
             .collect(),
     };
-    record_page(
-        std::iter::once(snapshot_codec::encode(&wire, work.limits.max_output_bytes)),
-        "cc-transcript.predicate-inputs/1",
-        next,
-        false,
-        work,
+    snapshot_codec::predicate_input_records(
+        &sonic_rs::to_value(&wire).map_err(|error| invalid(error.to_string()))?,
     )
 }