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