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