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