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