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