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