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