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