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