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