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