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