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