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