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