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