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