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