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