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