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