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