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