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