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