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