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