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