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