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