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